循环队列（顺序队列）

一 队列的定义

　队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表

　    （1）允许删除的一端称为队头（Front）。
（2）允许插入的一端称为队尾（Rear）。
（3）当队列中没有元素时称为空队列。
（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。

二 顺序队列

队列的顺序存储结构称为顺序队列，顺序队列实际上是运算受限的顺序表。

基本操作：

入队时：将新元素插入rear所指的位置，然后将rear加1。
出队时：删去front所指的元素，然后将front加1并返回被删元素。

三 循环队列

　为充分利用向量空间，克服"假上溢"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。即：循环队列中进行出队、入队操作时，头尾指针仍要加1，朝前移动。只不过当头尾指针指向向量上界（QueueSize-1）时，其加1操作的结果是指向向量的下界0。

（1）循环意义上的加1操作可以

[cpp] view plain copy print ?

1. ① 方法一：  
2.     if(i+1==QueueSize) //i表示front或rear  
3.         i=0;  
4.     else  
5.         i++;  
6.   
7. ② 方法二： 利用"模运算"  
8.     i=(i+1)%QueueSize；  

① 方法一：
    if(i+1==QueueSize) //i表示front或rear
        i=0;
    else
        i++;

② 方法二： 利用"模运算"
    i=(i+1)%QueueSize；

（2）循环队列的边界问题

循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"还是"满"。 

解决这个问题的方法至少有三种：
① 另设一布尔变量以区别队列的空和满；
② 少用一个元素的空间。约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满（注意：rear所指的单元始终为空）；
③使用一个计数器记录队列中元素的总数（即队列长度）。

（3）循环队列数据类型

[cpp] view plain copy print ?

1. #define QueurSize 100   //应根据具体情况定义该值  
2. typedef char DataType;  //DataType的类型依赖于具体的应用  
3. typedef struct{  
4.       int front;           //头指针，队非空时指向队头元素  
5.       int rear;           //尾指针，队非空时指向队尾元素的下一位置  
6.       int count;//计数器，记录队中元素总数  
7.       DataType data[QueueSize]  
8. }CirQueue;  

     #define QueurSize 100   //应根据具体情况定义该值
     typedef char DataType;  //DataType的类型依赖于具体的应用
     typedef struct{
           int front;           //头指针，队非空时指向队头元素
           int rear;           //尾指针，队非空时指向队尾元素的下一位置
           int count;//计数器，记录队中元素总数
           DataType data[QueueSize]
     }CirQueue;

（4）循环队列的基本运算

[cpp] view plain copy print ?

1. ① 置队空  
2.       void InitQueue(CirQueue *Q)  
3.       {  
4.               Q->front=Q->rear=0;  
5.               Q->count=0;     //计数器置0  
6.        }  
7.   
8. 　　② 判队空  
9.        int QueueEmpty(CirQueue *Q)  
10.        {  
11.             return Q->count==0;  //队列无元素为空  
12.         }  
13. 　　③ 判队满  
14. int QueueFull(CirQueue *Q)  
15.         {  
16.             return Q->count==QueueSize;  //队中元素个数等于QueueSize时队满  
17.          }  
18. 　　④ 入队  
19. void EnQueue(CirQueuq *Q,DataType x)  
20.          {  
21.             if(QueueFull((Q))  
22.             {  
23.                  printf("Queue overflow");     //队满上溢  
24.                  exit(1);  
25.             }  
26.             Q->count ++;                        //队列元素个数加1  
27.             Q->data[Q->rear]=x;                 //新元素插入队尾  
28.             Q->rear=(Q->rear+1)%QueueSize;      //循环意义下将尾指针加1  
29. 　　⑤ 出队  
30. DataType DeQueue(CirQueue *Q)  
31.           {  
32.               DataType temp;  
33.               if(QueueEmpty((Q))  
34.               {  
35.                  printf("Queue underflow");     //队空下溢  
36.                  exit(1);  
37.               }  
38.   
39.               temp=Q->data[Q->front];  
40.               Q->count--;                        //队列元素个数减1  
41.               Q->front=(Q->front+1)%QueueSize;   //循环意义下的头指针加1  
42.               return temp;  
43.            }  
44.   
45. 　　⑥取队头元素  
46. DataType QueueFront(CirQueue *Q)  
47.             {  
48.                 if(QueueEmpty(Q))  
49.                 {  
50.                  printf("Queue if empty.");  
51.                  exit(1);  
52.                 }  
53.                 return Q->data[Q->front];  
54.             }  

转载：http://blog.csdn.net/xsf50717/article/details/39937085