数据结构：队列的顺序存储结构（循环队列）

队列的定义：

---

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列的抽象数据类型：

ADT 队列(Queue)
Data
    同线性表，元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
    InitQueue(*Q):        初始化操作，建立一个空队列。
    DestroyQueue(*Q):     若队列Q存在，则销毁它。
    ClearQueue(*Q):       将队列清空。
    QueueEmpty(Q):        判断队列是否为空。
    GetHead(Q,*e):        若队列存在且非空，用e返回Q的队头元素。
    EnQueue(*Q,e):        若队列Q存在，插入新元素e到队列Q中并成为队尾元素。
    DeQueue(*Q,*e):       删除队列中的队头元素，并用e返回。
    QueueLength(Q):       返回队列Q的元素的个数。

endADT

线性表有顺序存储和链式存储，栈是线性表，所以有这两种存储方式，有顺序栈和链栈。同样队列作为一种特殊的线性表，也存在这两种存储方式。先来看队列的顺序存储结构。

队列的顺序存储结构同线性表的顺序存储结构存在着同样的问题，队头出队列要后面的元素依次向前移动，时间复杂度为O(n)。

因为队列的每次删除元素都是从队头，所以每次删除都有大量的元素要移动，这样算法的效率很不好。于是改进一下，队头不一定要在数组的下标为0的位置。也就是说删除一个元素，仅需要把队头指针向后移动一次。

同时让front指针指向队头元素，rear指针指向队尾元素的下一个位置。这样当front等于rear时，队列就为空。

但是此时还有问题，会有假溢出的现象。

解决这种问题的办法就是循环队列。让上面的队尾指针rear指向数组的下标0位置。

队列的这种头尾相接的顺序存储结构称为循环队列。

但是还存在一个问题：当队列空或者满的时候都是front==rear。那么这个要怎么判断呢？

（1）设置一个标志变量flag，当fron==rear且flag==0时，队列为空；当front==rear且flag==1时队列满。

（2）当队列为空时，条件就是front==rear，当队列满时修改条件，保留一个元素空间。也就是说队列满时，数组还有一个空闲单元。

这里假设队列的最大尺寸为QueueSize，所以队列满的条件是（rear+1）%QueueSize == front。

队列的长度为（rear-front+QueueSize）%QueueSize。

循环队列代码实现：

---

#include <iostream>
#include <stdlib.h>
using namespace std;
#define QueueSize 20

/********************************
*
*    循环队列的顺序存储结构代码
*
********************************/
typedef int QElemType;
typedef struct 
{
    QElemType data[QueueSize];
    int front;
    int rear;
}SqQueue;

/********************************
*
*    循环队列的操作函数实现代码
*
********************************/
/*初始化一个队列*/
bool InitQueue(SqQueue *Q)
{
    Q->front = 0;
    Q->rear = 0;

    return true;
}
/*返回Q的元素的个数，也就是队列的当前长度*/
int QueueLength(SqQueue Q)
{
    return (Q.rear-Q.front + QueueSize) % QueueSize;
}
/*若队列未满，插入元素e为Q的新队尾元素*/
bool EnQueue(SqQueue *Q, QElemType e)
{
    if((Q->rear + 1) % QueueSize == Q->front)
    {
        return false;
    }
    cout << "EnQueue Item " << e << endl;
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear + 1) % QueueSize;

    return true;
}
/*若队列不空，删除Q中队头的元素，用e返回其值*/
bool DeQueue(SqQueue *Q, QElemType *e)
{
    if(Q->front == Q->rear)
    {
        return false;
    }
    
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % QueueSize;
    cout << "DeQueue Item " << *e << endl;

    return true;
}
/*将队列清空*/
bool ClearQueue(SqQueue *Q)
{
    Q->front = 0;
    Q->rear = 0;
    return true;
}
/*判断队列是否为空*/
bool IsEmptyQueue(SqQueue Q)
{
    return Q.front == Q.rear;
}
/*返回队头元素*/
bool GetTop(SqQueue Q, QElemType *e)
{
    if(IsEmptyQueue(Q))
    {
        return true;
    }

    *e = Q.data[Q.front];
    cout << "Get Top Item:" << *e << endl;

    return true;
}
/*遍历队列中的各个元素*/
bool QueueTraverse(SqQueue Q)
{
    if(IsEmptyQueue(Q))
    {
        return false;
    }
    cout << "Queue Traverse ..." << endl;

    int count =  (Q.rear - Q.front + QueueSize) % QueueSize;
    for(int i = Q.front; i < Q.front + count; i++)
    {
        cout << Q.data[i] << ' '; 
    }
    cout << endl;

    return true;
}

void main(void)
{
    SqQueue sq;
    InitQueue(&sq);
    for(int i = 0; i < 10; i++)
    {
        EnQueue(&sq, i);
    }
    QueueTraverse(sq);

    if(!IsEmptyQueue(sq))
    {
        cout << "Queue Length: " << QueueLength(sq) << endl;
    }

    int result;
    GetTop(sq, &result);
    DeQueue(&sq, &result);
    DeQueue(&sq, &result);

    QueueTraverse(sq);

    for(int i = 0; i < 11; i++)
    {
        EnQueue(&sq, i);
    }
    GetTop(sq, &result);
    QueueTraverse(sq);

    system("pause");
}

执行结果：

单是顺序存储，若不是循环队列，算法的时间性能是不高的，但循环队列又面临着数组可能溢出的问题，所以还是要研究一下不需要担心队列长度的链式存储结构。