队列的链式存储结构

队列的顺序存储结构（参考前面文章：点击打开链接）比链式较为复杂些，顺序存储结构要构造循环队列; 但是链式就不需要，存储元素的内存 地址是随机的，用的时候再向os申请内存空间。链式存储结构中需要两个flag工作指针，过程相对较简单些。但是其中也有需要注意的细节。下面给出实现代码：

点击(此处)折叠或打开

1. #include<iostream>
   
2. using namespace std;
   
3. typedef struct Queue{  //队列结点结构
   
4.     char ch;
   
5.     Queue *next;
   
6. }*queue;
   
7. typedef struct flaging {  //flag指针结构
   
8.     queue front, rear;   
   
9. }*flag;
   
10. 
    
11. void initSqueue(queue);
    
12. void initflag(flag);
    
13. void createSqueue(queue, flag);
    
14. void pushSqueue(queue, flag, char);
    
15. void popSqueue(queue, flag);
    
16. void throughSqueue(queue, flag);
    
17. 
    
18. void initSqueue(queue q) {
    
19.     q = new Queue;
    
20. }
    
21. void initflag(flag fg) {
    
22.     fg = new flaging;
    
23. }
    
24. void createSqueue(queue q,flag fg){    
    
25.     cout << "输入入队的元素:" << endl;
    
26.     queue p,head;
    
27.     head = q;
    
28.     for (char ch; cin >> ch, ch != '#';) {
    
29. 
    
30.         p = new Queue;
    
31.         head->next=p;
    
32.         p->ch = ch;
    
33.         head = p;
    
34.         head->next = NULL;
    
35.     }
    
36.     fg->front=q->next;
    
37.     fg->rear = head;
    
38. }
    
39. void pushSqueue(queue q,flag fg,char ch) { //入队
    
40.     q = fg->rear;
    
41.     q->next = new Queue;
    
42.     q->next->ch = ch;
    
43.     q->next->next = NULL;
    
44.     fg->rear = q->next;
    
45. }
    
46. void popSqueue(queue q,flag fg){  //出队
    
47.     
    
48.     q = fg->front;
    
49.         cout << q->ch;
    
50.         fg->front = q->next;
    
51.         delete q;
    
52. }
    
53. void throughSqueue(queue q, flag fg) {//遍历队列，打印在队列中的元素
    
54.     q = fg->front;
    
55.     do{
    
56.         cout << q->ch << " ";
    
57.         q = q->next;
    
58.     } while (q != NULL);
    
59. }
    
60. 
    
61. int main(){
    
62.     Queue q;
    
63.     flaging fg;
    
64.     initSqueue(&q);
    
65.     initflag(&fg);
    
66.     createSqueue(&q, &fg);
    
67.     pushSqueue(&q, &fg, 'F');
    
68.     cout << "出队的元素是：";
    
69.     popSqueue(&q, &fg);
    
70.     cout << endl;
    
71.     cout << "出队的元素是：";
    
72.     popSqueue(&q, &fg);
    
73.     cout << endl;
    
74.     cout << "出队的元素是：";
    
75.     popSqueue(&q, &fg);
    
76.     cout << endl;
    
77.     cout << "在队列中的元素是:" << endl; 
    
78.     throughSqueue(&q, &fg);
    
79.     cout << endl;
    
80. }

运行结果：

该过程用下面图示简单的表示一下：

有朋友会问，为什么最后指向NULL结点,添加这一步似乎对程序的可读性没有带来多少好处，但是这一步关键之处，在 throughSqueue(queue q, flag fg)中，遍历整个队列时，用来判断遍历整个队列时退出的条件，对于该函数作用十分重要，但是如果不实现该函数功能的话，那么没有必要再构造出 NULL结点。队列的性质是从front指针处出队列，从rear指针处入队列，上面的示意图很清楚的看出这一性质，front，rear可以看成记忆指针，可以准确的告诉q指针该到什么位置工作，q指针可以看成是移动的。整个过程，画出图会很清晰，相信读者会有更精彩的功能实现。