队列的定义：
队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列的抽象数据类型：
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");
}
执行结果：
单是顺序存储，若不是循环队列，算法的时间性能是不高的，但循环队列又面临着数组可能溢出的问题，所以还是要研究一下不需要担心队列长度的链式存储结构。
来源：https://www.cnblogs.com/stemon/p/4283945.html