队列的顺序存储结构

队列的顺序存储结构相对于链式存储结构较为复杂，本文重点介绍队列顺序结构。下面简单的谈两个问题：
1.由于是顺序队列，很容易想到用数组来存储元素，假如一个队列的长度是10，就是一下可以放入10个元素，当9个元素出队后，又放入3个元素，此时是不是要再增长数组的长度呢？实际中不可能增加数组的长度而任内存空间的浪费，所以我们要构造循环队列，也就是当rear=（队列的长度-1），下一个入队元素的位置是rear=(rear+1)%(队列的长度），同理front也是如此。只要是顺序队列都是循环队列。
2.如何判断什么时候队列是空，什么时候队列已经满了呢？这个是实际中不可避免的问题。在顺序队列中，我们通常用front,rear两个"指针"来进行入队和出队的操作，在队列的初始化时，front=rear,此时队列为空，这是队列为空的判断条件;那么什么时候队列满了呢，通常留一个存储空间不存储元素,此时判断队列满的条件就是(rear+1)%(队列的长度) =  front,解决了当rear = front时，不知道是队满还是队空的问题。
简单的介绍了循环队列中的棘手的问题，下面给出简单实现的代码：

点击(此处)折叠或打开

1. #include<iostream>
   
2. #define MAX_SIZE 10
   
3. using namespace std;
   
4. 
   
5. struct Squeue {
   
6.     int data[MAX_SIZE];
   
7.     int rear, front;
   
8. };
   
9. 
   
10. void initSqueue(Squeue *);
    
11. void emptySqueue(Squeue *);
    
12. void fullSqueue(Squeue *);
    
13. void Insqueue(Squeue *, int);
    
14. void Outsqueue(Squeue *, int *);
    
15. void ergodicSqueue(Squeue *);
    
16. 
    
17. void initSqueue(Squeue *q) {
    
18.     q->front = 0;
    
19.     q->rear = 0;
    
20. }
    
21. void emptySqueue(Squeue *q) {
    
22.     if (q->rear == q->front) {                  //判断队列空的条件
    
23.         cout << "队列为空！！！" << endl;
    
24.         exit(-1);
    
25.     }
    
26.     else
    
27.         return;
    
28. }
    
29. void fullSqueue(Squeue *q) {
    
30.     if ((q->rear + 1) % MAX_SIZE == q->front){   //判断队列已满的条件
    
31.     cout << "队列已满!!!" << endl;
    
32.     exit(-1);
    
33.     }
    
34.     else
    
35.         return;
    
36. }
    
37. void Insqueue(Squeue *q, int e) {
    
38.     fullSqueue(q);                      //入队时判断队列是否已满
    
39.     q->data[q->rear] = e;
    
40.     q->rear = (q->rear + 1) % MAX_SIZE;
    
41. }
    
42. void Outsqueue(Squeue *q, int *e) {
    
43.     emptySqueue(q);                     //出队时判断队列是否已空
    
44.     *e = q->data[q->front];
    
45.     q->front = (q->front + 1) % MAX_SIZE;
    
46. }
    
47. void ergodicSqueue(Squeue *q) {          //对队列进行入队出队操作后，打印在队列中的元素
    
48.     int i = 0;
    
49.     cout << "在队列中的元素是:";
    
50.     while (q->front != q->rear) {
    
51.         cout << q->data[q->front] << ",";
    
52.         q->front = (q->front + 1) % MAX_SIZE;
    
53.         i++;
    
54.     }
    
55.     cout << endl;
    
56.     cout << "队列中的元素个数为:" << i << endl; //统计队列中元素的个数
    
57. }
    
58. int main() {
    
59. 
    
60.     Squeue queue;
    
61.     int e = 0;
    
62.     initSqueue(&queue);
    
63.     for (int i = 1; i <= 9; i++) {
    
64.         Insqueue(&queue, i);
    
65.     }
    
66.    
67.     Outsqueue(&queue, &e);
    
68.     cout << "出队的元素是:" << e << endl;
    
69.     Outsqueue(&queue, &e);
    
70.     cout << "出队的元素是:" << e << endl;
    
71. 
    
72.     Insqueue(&queue, 10);
    
73.     Outsqueue(&queue, &e);
    
74.     cout << "出队的元素是:" << e << endl;
    
75.     ergodicSqueue(&queue);
    
76. }

执行结果：

以上只是粗略的介绍，当然更为详细的是画图分析该过程，由于画图比较繁琐，这里不作展示。

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29876893/viewspace-1847566/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/29876893/viewspace-1847566/