队列的顺序存储结构——循环队列 图解和代码实现

转自http://blog.csdn.net/ggxxkkll/article/details/8661569

队列的顺序存储结构——循环队列

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

队空的条件： front=rear

队满的条件是： （rear+1）%QueueSize=front

 

 

图片详解：

 

CirQueue.h

 

[cpp]  view plain copy

1. //CirQueue.h  
2. #ifndef CIRQUEUE_H  
3. #define CIRQUEUE_H  
4.   
5. const int QueueSize=100;  //定义存储队列元素的数组的最大长度  
6.   
7. template <class T>        //定义模板类CirQueue  
8. class CirQueue  
9. {  
10. public:  
11.     CirQueue( );        //构造函数，置空队  
12.     ~ CirQueue( );               //析构函数  
13.     void EnQueue(T x);           //将元素x入队  
14.     T DeQueue( );                //将队头元素出队  
15.     T GetQueue( );               //取队头元素（并不删除）  
16.     bool Empty( );               //判断队列是否为空  
17. private:  
18.     T data[QueueSize];           //存放队列元素的数组  
19.     int front, rear;    //队头和队尾指针，分别指向队头元素的前一个位置和队尾元素的位置  
20. };  
21.   
22. #endif  

 

CirQueue.cpp

 

[cpp]  view plain copy

1. //CirQueue.cpp  
2. #include "CirQueue.h"  
3.   
4. /* 
5.  * 前置条件：队列不存在 
6.  * 输    入：无 
7.  * 功    能：初始化队列 
8.  * 输    出：无 
9.  * 后置条件：创建一个空队列 
10.  */  
11.   
12. template <class T>  
13. CirQueue<T>::CirQueue( )   
14. {  
15.     front=rear=0;  
16. }   
17.   
18. /* 
19.  * 前置条件：队列已存在 
20.  * 输    入：无 
21.  * 功    能：销毁队列 
22.  * 输    出：无 
23.  * 后置条件：释放队列所占用的存储空间 
24.  */  
25.   
26. template <class T>  
27. CirQueue<T>::~CirQueue( )  
28. {  
29.   
30. }  
31.   
32. /* 
33.  * 前置条件：队列已存在 
34.  * 输    入：元素值x 
35.  * 功    能：在队尾插入一个元素 
36.  * 输    出：如果插入不成功，抛出异常 
37.  * 后置条件：如果插入成功，队尾增加了一个元素 
38.  */  
39.   
40. template <class T>   
41. void CirQueue<T>::EnQueue(T x)  
42. {  
43.     if ((rear+1) % QueueSize ==front) throw "上溢";  
44.     rear=(rear+1) % QueueSize;   //队尾指针在循环意义下加1  
45.     data[rear]=x;                //在队尾处插入元素  
46. }  
47.   
48. /* 
49.  * 前置条件：队列已存在 
50.  * 输    入：无 
51.  * 功    能：删除队头元素 
52.  * 输    出：如果删除成功，返回被删元素值，否则，抛出删除异常 
53.  * 后置条件：如果删除成功，队头减少了一个元素 
54.  */  
55.   
56. template <class T>   
57. T CirQueue<T>::DeQueue( )  
58. {  
59.     if (rear==front) throw "下溢";   
60.     front=(front+1) % QueueSize;    //队头指针在循环意义下加1  
61.     return data[front];             //读取并返回出队前的队头元素，注意队头指针  
62. }  
63.                                    //指向队头元素的前一个位置  
64. /* 
65.  * 前置条件：队列已存在 
66.  * 输    入：无 
67.  * 功    能：读取队头元素 
68.  * 输    出：若队列不空，返回队头元素 
69.  * 后置条件：队列不变 
70.  */  
71.   
72. template <class T>  
73. T CirQueue<T>::GetQueue( )  
74. {     
75.     int i;  
76.     if (rear==front) throw "下溢";   
77.     i=(front+1) % QueueSize;  //注意不要给队头指针赋值  
78.     return data[i];  
79. }  
80.   
81. /* 
82.  * 前置条件：队列已存在 
83.  * 输    入：无 
84.  * 功    能：判断队列是否为空 
85.  * 输    出：如果队列为空，返回1，否则，返回0 
86.  * 后置条件：队列不变 
87.  */  
88.   
89. template <class T>   
90. bool CirQueue<T>::Empty( )   
91. {  
92.     if (front==rear)   
93.         return 1;   
94.     else   
95.         return 0;  
96. }  

CirQueue.h

 

[cpp]  view plain copy

1. //CirQueue.h  
2. #ifndef CIRQUEUE_H  
3. #define CIRQUEUE_H  
4.   
5. const int QueueSize=100;  //定义存储队列元素的数组的最大长度  
6.   
7. template <class T>        //定义模板类CirQueue  
8. class CirQueue  
9. {  
10. public:  
11.     CirQueue( );        //构造函数，置空队  
12.     ~ CirQueue( );               //析构函数  
13.     void EnQueue(T x);           //将元素x入队  
14.     T DeQueue( );                //将队头元素出队  
15.     T GetQueue( );               //取队头元素（并不删除）  
16.     bool Empty( );               //判断队列是否为空  
17. private:  
18.     T data[QueueSize];           //存放队列元素的数组  
19.     int front, rear;    //队头和队尾指针，分别指向队头元素的前一个位置和队尾元素的位置  
20. };  
21.   
22. #endif  

 

CirQueue.cpp

 

[cpp]  view plain copy

1. //CirQueue.cpp  
2. #include "CirQueue.h"  
3.   
4. /* 
5.  * 前置条件：队列不存在 
6.  * 输    入：无 
7.  * 功    能：初始化队列 
8.  * 输    出：无 
9.  * 后置条件：创建一个空队列 
10.  */  
11.   
12. template <class T>  
13. CirQueue<T>::CirQueue( )   
14. {  
15.     front=rear=0;  
16. }   
17.   
18. /* 
19.  * 前置条件：队列已存在 
20.  * 输    入：无 
21.  * 功    能：销毁队列 
22.  * 输    出：无 
23.  * 后置条件：释放队列所占用的存储空间 
24.  */  
25.   
26. template <class T>  
27. CirQueue<T>::~CirQueue( )  
28. {  
29.   
30. }  
31.   
32. /* 
33.  * 前置条件：队列已存在 
34.  * 输    入：元素值x 
35.  * 功    能：在队尾插入一个元素 
36.  * 输    出：如果插入不成功，抛出异常 
37.  * 后置条件：如果插入成功，队尾增加了一个元素 
38.  */  
39.   
40. template <class T>   
41. void CirQueue<T>::EnQueue(T x)  
42. {  
43.     if ((rear+1) % QueueSize ==front) throw "上溢";  
44.     rear=(rear+1) % QueueSize;   //队尾指针在循环意义下加1  
45.     data[rear]=x;                //在队尾处插入元素  
46. }  
47.   
48. /* 
49.  * 前置条件：队列已存在 
50.  * 输    入：无 
51.  * 功    能：删除队头元素 
52.  * 输    出：如果删除成功，返回被删元素值，否则，抛出删除异常 
53.  * 后置条件：如果删除成功，队头减少了一个元素 
54.  */  
55.   
56. template <class T>   
57. T CirQueue<T>::DeQueue( )  
58. {  
59.     if (rear==front) throw "下溢";   
60.     front=(front+1) % QueueSize;    //队头指针在循环意义下加1  
61.     return data[front];             //读取并返回出队前的队头元素，注意队头指针  
62. }  
63.                                    //指向队头元素的前一个位置  
64. /* 
65.  * 前置条件：队列已存在 
66.  * 输    入：无 
67.  * 功    能：读取队头元素 
68.  * 输    出：若队列不空，返回队头元素 
69.  * 后置条件：队列不变 
70.  */  
71.   
72. template <class T>  
73. T CirQueue<T>::GetQueue( )  
74. {     
75.     int i;  
76.     if (rear==front) throw "下溢";   
77.     i=(front+1) % QueueSize;  //注意不要给队头指针赋值  
78.     return data[i];  
79. }  
80.   
81. /* 
82.  * 前置条件：队列已存在 
83.  * 输    入：无 
84.  * 功    能：判断队列是否为空 
85.  * 输    出：如果队列为空，返回1，否则，返回0 
86.  * 后置条件：队列不变 
87.  */  
88.   
89. template <class T>   
90. bool CirQueue<T>::Empty( )   
91. {  
92.     if (front==rear)   
93.         return 1;   
94.     else   
95.         return 0;  
96. }