队列学习

定义

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

1. 允许插入的一端叫做队尾（rear）
2. 允许删除的一端叫做队头（front）
3. 当队列中没有元素时叫做空队列
4. 队列是一种先进先出的线性表，也称为FIFO表

顺序队列

顺序队列的定义

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

顺序队列的表示

1. 顺序队列用一个向量空间来存放当前的队列中的元素
2. 由于队列中队头和队尾的位置是变化的，设置两个指针front和rear分别指示队头元素和队尾元素在向量空间中的位置，它们的位置在队列初始化时均应置为0

顺序队列的基本操作

1. 入队时：将新元素插入rear所指的位置，并将rear+1
2. 出队时：删除front所指的元素，并将front+1

注意：

1. 当头尾指针相等时，队列为空
2. 在非空队列里，队头指针始终指向队头元素，队尾指针始终指向队尾元素的下一个位置

顺序队列中的溢出现象

1. 下溢：队列为空时，做出队操作产生的溢出现象
2. 真上溢：当队列满时，做入队操作产生的空间溢出现象。
3. 假上溢：由于入队和出队操作中，队头指针只增加不减少，致使被删除的元素空间永远无法重新利用，从而导致入队操作时产生假上溢现象。

循环队列

为了充分利用初始分配的向量空间，克服“假上溢”的方法是：将向量空间想像成一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列(circular queue).

循环队列的基本操作

当循环队列进行入队和出队操作时，队头和队尾指针仍要+1。只不过当头指针指向向量上界（queuesize - 1）时，其+1操作是指向向量空间的下界0.这种循环意义下的+1操作用代码描述为

1. [cpp] view plain copy print ?

   1. if(front == queuesize - 1) 
   2. { 
   3.     front = 0; 
   4. }else 
   5. { 
   6.     front ++; 
   7. } 

   if(front == queuesize - 1)
   {
   	front = 0;
   }else
   {
   	front ++;
   }

   
   
2. [cpp] view plain copy print ?

   1. front = (front + 1) % queuesize; 

   front = (front + 1) % queuesize;

   
   
   

循环队列边界处理的方法

1. 另设一个布尔变量来区分队列的空和满。
2. 设一个计数器记录当前队列中的元素

循环队列的类型定义

[cpp] view plain copy print ?

1. #define queuesize 100001    //最大队列长度 
2. #define type int    //队列中存储的元素类型 
3.  
4. struct queue 
5. { 
6.     int front; 
7.     int rear; 
8.     type data[queuesize]; 
9.     int count;  //记录队列中的元素 
10. }; 

#define queuesize 100001	//最大队列长度
#define type int	//队列中存储的元素类型

struct queue
{
	int front;
	int rear;
	type data[queuesize];
	int count;	//记录队列中的元素
};

循环队列的基本操作

[cpp] view plain copy print ?

1. /**
2. * Description:队列初始化
3. */ 
4. void InitQueue(struct queue *Q) 
5. { 
6.     Q -> front = Q -> rear = 0; 
7.     Q -> count = 0; 
8. } 
9.  
10. /**
11. * Description:队列判空
12. */ 
13. int QueueEmpty(struct queue *Q) 
14. { 
15.     int flag; 
16.  
17.     flag = (Q -> count == 0)? 1 : 0; 
18.  
19.     return flag; 
20. } 
21.  
22. /**
23. * Description:队列判满
24. */ 
25. int QueueFull(struct queue *Q) 
26. { 
27.     int flag; 
28.  
29.     flag = (Q -> count == queuesize)? 1 : 0; 
30.  
31.     return flag; 
32. } 
33.  
34. /**
35. * Description:入队操作
36. */ 
37. void EnQueue(struct queue *Q, type element) 
38. { 
39.     int flag; 
40.  
41.     flag = QueueFull(Q); 
42.     if(!flag) 
43.     { 
44.         Q -> data[Q -> rear] = element; 
45.         Q -> count ++; 
46.         Q -> rear = (Q -> rear + 1) % queuesize; 
47.     }else 
48.     { 
49.         printf("failed\n"); 
50.     } 
51. } 
52.  
53. /**
54. * Description:出队操作
55. */ 
56. void Dequeue(struct queue *Q) 
57. { 
58.     int flag; 
59.     type element; 
60.  
61.     flag = QueueEmpty(Q); 
62.  
63.     if(!flag) 
64.     { 
65.         element = Q -> data[Q -> front]; 
66.         Q -> front = (Q -> front + 1) % queuesize; 
67.         Q -> count --; 
68.     }else 
69.     { 
70.         printf("failed\n"); 
71.     } 
72. } 
73.  
74. /**
75. * Description:查找队列中的指定元素
76. */ 
77. void QueueSearch(struct queue *Q, int k) 
78. { 
79.     if(!QueueEmpty(Q) && 1 <= k <= queuesize) 
80.     { 
81.         printf("%d\n",Q -> data[k - 1]); 
82.     }else 
83.     { 
84.         printf("failed\n"); 
85.     } 
86. }