数据结构---队列

队列：
只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
先进先出的线性表（Firset In First Out），允许插入的一端称为队尾，允许删除的一端称为队头。（类似于排队）
引入两个指针，front指向对头元素，rear指向队尾元素的下一个位置

这样队列的缺点：
如果rear指向队列最大处的下一个位置，但是front没有指向队列开始位置，这个时候无法添加元素，前面的空间就浪费了

循环队列：
使队列的头尾相接
接着上面的那个，此时队列中再添加元素使，rear指向队列的开始

此时的问题：
空队列时，front=rear，满队列时，front=raar，无法判断队列是空还是满

解决方法：
方法一：设置一个标志变量flag，当front=rear且flag=0时队列为空；当frong=rear且flag=1时队列为满
方法二：队列为空时，条件就是front-rear，当队列为满时，我们保留一个元素空间

判断队列满的公式：
(rear + 1) % QueueSize == front
因为rear可能再front的前面也可能再后面

获得队列长度的公式：
(rear - front + QueueSize) % QueueSize

typedef int QElemType;
typedef struct
{
    QElemType data[MAXSIZE];
    int front;  // 头指针
    int rear;  // 尾指针
}SqQueue;

循环队列的初始化：

initQueue(SqQueue *Q)
{
    Q->front = 0;
    Q->rear = 0;
}

循环队列求长度：

int queueLength(SqQueue *Q)
{
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

循环队列的入队操作：

inQueue(SqQueue *Q, QElemType e)
{
    if((Q->rear+1)%MAXSIZE == Q->front) // 循环队列满
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear+1)%MAXSIZE;  // rear指针后移
}

循环队列的出队操作：

outQueue(SqQueue *Q, QElemType e)
{
    if(Q->front == Q->rear) // 队空
    *e = Q->data[Q->front];
    Q->front = (Q->front+1)%MAXSIZE; // front指针后移
}

队列的链式存储结构：

线性表的单链表，只是尾进头出
队头指针指向链队列的头结点，队尾指针指向终端结点
空队列时，front和rear都指向头结点

typedef int QElemType;
typedef struct QNode  // 结点结构
{
    QElemType data;
    struct QNode *next;
}QNode, *QueuePtr;
typedef struct  // 链表结构
{
    QueuePtr front, rear;  // 队头，队尾指针
}LinkQueue;

入队操作：

inQueue(LinkQueue *Q, QElemType e)
{
    QueuePtr s = (QueuePtr) malloc(sizeof(QNode));
    if(!s)  // 存储分配失败
    s->data = e;
    s->next = NULL;
    Q->rear->next = s;  // s赋为原队列的队尾
    Q->rear = s;  // 将s设置为当前队尾
}

出队操作：

outQueue(LinkQueue *Q, QElemType *e)
{
    QueuePtr p;
    if(Q->front == Q->rear)  // 队空
    p = Q->front->next;  // 删除头结点的下一个结点
    *e = p->data;
    Q->front->next = p->next;//头结点的下一个结点指向欲删除结点的下一个
    // 如果链表中只有一个结点，删除后队尾=队头
    if(Q->rear == p)
    {
        Q->rear = Q->front;
    }
    free(p);
}