数据结构：队列

1.定义

　　可以实现“先进先出”的存储结构

2. 分类

　　链式队列　　　　　　　　——用链表实现

　　　　只允许在链表的头部删除，链表的尾部增加，就是队列

　　静态队列（数组队列）　　——用数组实现

　　　　静态队列通常都必须是循环队列

　　　　循环队列的讲解：

　　　　　　1.静态队列为什么必须是循环队列

　　　　　　2.循环队列需要几个参数来确定

　　　　　　　　需要2个参数来确定

　　　　　　　　　　front

　　　　　　　　　　rear

　　　　　　3.循环队列各个参数的含义

　　　　　　　　2个参数不同场合有不同的含义

　　　　　　　　1）队列初始化

　　　　　　　　　　front和rear的值都是零

　　　　　　　　2）队列非空

　　　　　　　　　　front代表队列的第一个元素

　　　　　　　　　　rear代表的队列的最后一个有效元素的下一个元素

　　　　　　　　3）队列空

　　　　　　　　　　front和rear的值相等，但是不一定是零(front++，front=rear，队列为空)

　　　　　　4.循环队列入队伪算法讲解

　　　　　　　　　　r移动

　　　　　　　　1） 将值存入r所代表的位置

　　　　　　　　2） 对于r 

　　　　　　　　　　错误写法 r = r + 1

　　　　　　　　　　正确写法 r = (r+1)%数组长度，解决了当r=5的时候的循环问题

　　　　　　5.循环队列出队伪算法讲解

　　　　　　　　　　f移动

　　　　　　　　　　f  = (f + 1)%数组长度  （数组长度对于下表的话为6）

　　　　　　6.如何判断循环队列是否为空

　　　　　　　　　　如果front与rear的值相等，则该队列一定为空

　　　　　　7.如何判断循环队列是否已满

　　　　　　　　　两种方式

　　　　　　　　　　1）多增加一个标志参数

　　　　　　　　　　2）如果r和f紧挨着，则队列已满（相当于浪费一个元素的位置）

 

　　　　　　　　　　　　相当于当4的位置上填入s之后，r移动到5的位置，5的位置不填值，已满

　　　　　　　　　　　　 　if ((r+1)%数组长度 == f)

　　　　　　　　　　　　　　　　已满

　　　　　　　　　　　　　else

　　　　　　　　　　　　　　　　不满

//原则：一般来说不管是链表还是队列，头指向头个有实质意义结点，则尾部为尾部结点指向的下一个结点，反之相同

3.

当要删除中的时候，指针front直接循环回去，不指向“中”，rear指针向下移动一位即可

 

3.队列的基本应用

　　　所有和时间相关的操作都与队列有关

 

代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <stdbool.h>

typedef struct Queue
{
    int * pBase;
    int front;
    int rear;
}QUEUE;

void init(QUEUE *);
bool en_queue(QUEUE *, int val);
void traverse_queue(QUEUE *);
bool full_queue(QUEUE *);
bool out_queue(QUEUE *, int * );
bool empty_queue(QUEUE * );
int main()
{
    QUEUE Q;
    int val;
    init(&Q);
    en_queue(&Q, 1);https://i.cnblogs.com/posts
    en_queue(&Q, 2);
    en_queue(&Q, 3);
    en_queue(&Q, 4);
    en_queue(&Q, 5);
    en_queue(&Q, 6);
    traverse_queue(&Q);
    
    

    if (out_queue(&Q, &val))
    {
        printf("出队成功，出队成功的元素是：%d\n", val);
    }
    else
    {
        printf("出队失败\n");
    }
    traverse_queue(&Q);
    return 0;
}

void init(QUEUE *pQ)
{
    pQ->pBase = (int *)malloc(sizeof(int) * 6);
    pQ->front = 0;
    pQ->rear = 0;
}


bool full_queue(QUEUE *pQ)
{
    if ((pQ->rear + 1) % 6 == pQ->front)
    {
        return true;
    }
    else
    {
        return false;
    }
}


bool en_queue(QUEUE *pQ, int val)
{
    if (full_queue(pQ))
    {
        return false;
    }
    else
    {
        pQ->pBase[pQ->rear] = val;
        pQ->rear = (pQ->rear+1) % 6;
        return true;
    }
}

void traverse_queue(QUEUE * pQ)
{
    int i = pQ->front;
    while(i != pQ->rear)
    {
        printf("%d ", pQ->pBase[i]);
        i = (i+1) % 6;
    }
    return;
}

bool empty_queue(QUEUE * pQ)
{
    if (pQ->front == pQ->rear)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool out_queue(QUEUE *pQ, int * pVal)
{
    if (empty_queue(pQ))
    {
        return false;
    }
    else
    {
        *pVal = pQ->pBase[pQ->front];
        pQ->front = (pQ->front + 1) % 6;
        return true;
    }
}