数据结构复习之［循环队列］

 

线性结构的两种常见应用之二队列

定义：

一种可以实现“先进先出”的存储结构。

分类：

离散(链式)队列--用链表实现

静态(连续)队列--用数组实现

静态队列通常必须是循环队列

循环队列的必须要弄清除的7个问题：

1.静态队列为什么必须是循环队列

由于连续空间的问题，为了节省空间，方便操作，速度快等优点。

2.循环队列需要几个参数来确定

需要2个参数来确定

3.循环队列各个参数的含义

2个参数不同场合有不同的含义

1).队列初始化

front = rear = 0

2).队列非空

front代表的是队列的第一个元素

rear代表的是队列的最后一个有效元素

3).队列空

front = rear  但不一定为零

4.循环队列入队伪算法讲解

两步完成：

1.将值存入rear所代表的位置

2.错误的写法：rear＝ rear＋ 1；

  正确的写法：rear＝（rear＋ 1）％数组的长度 

5.循环队列出队伪算法讲解

front＝（front＋ 1）％数组的长度

6.如何判断循环队列是否为空

如果front与 rear的值相等，

则该队列就一定为空

7.如何判断循环队列是否已满

预备知识：

front的值可能比rear大，可能比他小，也可能相等

两种方式：

1.多增加一个标识参数

2.不用数组的最后一个元素［通常使用第二种方式］

如果rear和 front的值紧挨着，则队列已满

if（（rear＋1）％数组长度＝＝ front）

已满

else

不满

循环队列程序演示:

view plain copy to clipboard print ?

1. #include <stdio.h>   
2. #include <stdlib.h>   
3.   
4. #define M 6 //数组长度   
5.   
6. #define bool char //c语言中没有bool类型,自己添加的   
7. #define true 1   
8. #define false 0   
9.   
10. typedef struct Queue  
11. {  
12.     int * pBase;//数组首地址，相当于数组名   
13.     int front;  
14.     int rear;  
15. }QUEUE;  
16.   
17. void init(QUEUE *);//初始化队列   
18. bool en_queue(QUEUE *,int);//入队列   
19. bool out_queue(QUEUE *, int *);//出队列   
20. void traverse_queue(QUEUE *);//遍历队列   
21. bool full_queue(QUEUE *);//判断队列是否为满   
22. bool empty_queue(QUEUE *);//判断队列是否为空   
23.   
24.   
25.   
26. int main (int argc, const char * argv[])  
27. {  
28.       
29.     QUEUE Q;  
30.     int val;  
31.     init(&Q);  
32.     //测试数据   
33.     en_queue(&Q, 1);  
34.     en_queue(&Q, 2);  
35.     en_queue(&Q, 3);  
36.     en_queue(&Q, 4);  
37.     en_queue(&Q, 5);  
38.     en_queue(&Q, 6);  
39.     en_queue(&Q, 7);  
40.     en_queue(&Q, 8);  
41.   
42.     traverse_queue(&Q);  
43.       
44.     if (out_queue(&Q, &val))  
45.     {  
46.         printf("出队成功，队列出队元素为:%d\n",val);  
47.     }  
48.     else  
49.         printf("出队失败!");  
50.       
51.     traverse_queue(&Q);  
52.   
53.     return 0;  
54. }  
55.   
56. void init(QUEUE *pQ)  
57. {//初始化队列   
58.     pQ->pBase = (int *)malloc(sizeof(int) * M);  
59.     pQ->front = 0;  
60.     pQ->rear = 0;  
61.     return;  
62. }  
63.   
64.   
65. bool full_queue(QUEUE * pQ)  
66. {//队列是否为满   
67.     if ((pQ->rear + 1) % M == pQ->front) {  
68.         return true;  
69.     }  
70.     else   
71.         return false;  
72. }  
73.   
74. bool en_queue(QUEUE * pQ,int val)    
75. {//入队列   
76.     if (full_queue(pQ)) {  
77.         return false;  
78.     }  
79.     else  
80.     {  
81.         pQ->pBase[pQ->rear] = val;  
82.         pQ->rear = (pQ->rear + 1) % M;  
83.         return true;  
84.     }  
85. }  
86.   
87. void traverse_queue(QUEUE * pQ)  
88. {//遍历队列   
89.     int i = pQ->front;  
90.       
91.     while(i != pQ->rear)  
92.     {  
93.         printf("%d  ",pQ->pBase[i]);  
94.         i = (i+1) % M;  
95.     }  
96.     return;   
97. }  
98.   
99. bool empty_queue(QUEUE * pQ)  
100. {//队列是否为空   
101.     if (pQ->front == pQ->rear) {  
102.         return true;  
103.     }  
104.     else  
105.         return false;   
106. }  
107.   
108. bool out_queue(QUEUE * pQ, int * pVal)  
109. {//出队列   
110.     if (empty_queue(pQ)) {  
111.         return false;  
112.     }  
113.     else  
114.     {  
115.         *pVal = pQ->pBase[pQ->front];  
116.         pQ->front = (pQ->front + 1) % M;  
117.         return true;  
118.     }  
119. }