基本数据结构：链式队列

 　队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表
　　（1）允许删除的一端称为队头（Front）。
　　（2）允许插入的一端称为队尾（Rear）。
　　（3）当队列中没有元素时称为空队列。
　　（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。

    　队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（即不允许"加塞"），每次离开的成员总是队列头上的（不允许中途离队），即当前"最老的"成员离队。

队列定义如下：

[cpp]  view plain copy

1. #ifndef LINKEDQUEUE  
2. #define LINKEDQUEUE  
3. #include <iostream>  
4. using std::ostream;    
5.   
6. template <typename T>  
7. class LinkedQueue  
8. {  
9. private:  
10.     struct Node  
11.     {  
12.         T data;//值域  
13.         Node *next;//后继  
14.   
15.         Node(Node *node = nullptr) : next(node)  
16.         {  
17.   
18.         }  
19.   
20.         Node(const T &value,Node *node = nullptr) : data(value),next(node)  
21.         {  
22.   
23.         }  
24.     };  
25.   
26.     Node *front;//头  
27.     Node *rear;//尾  
28.   
29. public:  
30.   
31.     LinkedQueue() : front(nullptr),rear(nullptr)  
32.     {  
33.   
34.     }  
35.   
36.     ~LinkedQueue()  
37.     {  
38.         makeEmpty();  
39.     }  
40.   
41.     void makeEmpty()//队列清空  
42.     {  
43.         Node *p ;  
44.         while(front)   
45.         {  
46.             p = front;  
47.             front = front->next;  
48.             delete p;  
49.         }  
50.     }  
51.   
52.     bool enQueue(const T &value)//进队  
53.     {  
54.         if(isEmpty())  
55.         {  
56.             front = rear = new Node(value);  
57.               
58.             return front == nullptr ? true : false;  
59.         }  
60.         else  
61.         {  
62.             rear->next = new Node(value);  
63.             rear = rear->next;  
64.   
65.             return rear == nullptr ? true : false;  
66.         }  
67.     }  
68.   
69.     bool deQueue(T &x)//出队  
70.     {  
71.         if(isEmpty())  
72.         {  
73.             return false;  
74.         }  
75.         else  
76.         {  
77.             Node *p = front;  
78.             x = front->data;  
79.             front = front->next;  
80.             delete p;  
81.             return true;  
82.         }  
83.     }  
84.   
85.     bool isEmpty() const  
86.     {  
87.         return front == nullptr;  
88.     }  
89.   
90.     bool getFront(T &x)  
91.     {  
92.         if(isEmpty())  
93.         {  
94.             return false;  
95.         }  
96.         else  
97.         {  
98.             Node *p = front;  
99.             x = front->data;  
100.             return true;  
101.         }  
102.     }  
103.   
104.     int size()  
105.     {  
106.         Node *p = front;  
107.         int k = 0;  
108.         while(p)  
109.         {  
110.             p = p->next;  
111.             ++k;  
112.         }  
113.   
114.         return k;  
115.     }  
116.   
117.     friend ostream & operator<<(ostream &out,LinkedQueue<T> &lq)  
118.     {  
119.         Node *p = lq.front;  
120.         for(int i = 1; i <= lq.size(); i++)  
121.         {  
122.             out << "#" << i <<":" << p->data << endl;  
123.             p = p->next;  
124.         }  
125.   
126.         return out;  
127.     }  
128. };  
129.   
130. #endif  

测试代码如下：

[cpp]  view plain copy

1. #include "linkedQueue.h"  
2. #include <fstream>  
3. using std::cin;    
4. using std::cout;    
5. using std::endl;    
6. using std ::ifstream;  
7.   
8.   
9. int main()  
10. {  
11.     ifstream fin("data.txt");  
12.     LinkedQueue<int> que;  
13.     int data;  
14.     while (!fin.eof()){  
15.         fin >> data;  
16.         que.enQueue(data);  
17.     }  
18.     cout << "The queue in the file is:\n" << que << endl;  
19.     que.getFront(data);  
20.     cout << "The front in the queue is: " << data << endl;  
21.   
22.     cout << "Delete the front in turn, the result is:" << endl;  
23.     int len = que.size();  
24.     for(int i = 0; i < len; i++){  
25.         que.deQueue(data);  
26.         cout << "Delete " << data << ", then the queue is:\n";  
27.         cout << que << endl;  
28.     }  
29.   
30.     system("pause");  
31.     return 0;  
32. }