数据结构基础(14) --链式队列的设计与实现

  链式队列是基于单链表的一种存储表示, 其形状如下图所示:

 

    (队列的队头指针指向单链表的第一个结点, 队尾指针指向单链表的最后一个结点, 注意没有无用的空[头/尾]节点)

    用单链表表示的链式队列特别适合于数据元素变动比较大的情况, 而且不存在队列满而产生溢出的情况;

 

链式队列结点构造:

[这次我们将节点构造成了类LinkQueue的嵌套类]

[cpp] view plain copy

1. struct ChainNode  
2. {  
3.     ChainNode(const Type &_data, ChainNode *_next = NULL)  
4.         :data(_data), next(_next) {}  
5.   
6.     Type data;  
7.     ChainNode *next;  
8. };  

链式队列构造:

[cpp] view plain copy

1. template <typename Type>  
2. class LinkQueue  
3. {  
4.     template <typename T>  
5.     friend ostream &operator<<(ostream &os, LinkQueue<T> &queue);  
6. public:  
7.     LinkQueue();  
8.     ~LinkQueue();  
9.     bool isEmpty() const;  
10.   
11.     void push(const Type &data);  
12.     void pop();  
13.   
14.     //返回队首元素  
15.     const Type &front() const;  
16.     //返回队尾元素  
17.     const Type &back() const;  
18.     //清空队列  
19.     void makeEmpty();  
20.   
21. private:  
22.     struct ChainNode  
23.     {  
24.         ChainNode(const Type &_data, ChainNode *_next = NULL)  
25.             :data(_data), next(_next) {}  
26.   
27.         Type data;  
28.         ChainNode *next;  
29.     };  
30.   
31. private:  
32.     ChainNode *m_front; //队首指针[注意不是指向一个无用的空节点]  
33.     ChainNode *m_back;  //队尾指针[注意不是指向一个无用的空节点]  
34. };  

队列的构造与析构:

[cpp] view plain copy

1. template <typename Type>  
2. LinkQueue<Type>::LinkQueue()  
3. {  
4.     m_front = m_back = NULL;  
5. }  
6. template <typename Type>  
7. LinkQueue<Type>::~LinkQueue()  
8. {  
9.     makeEmpty();  
10. }  

队列的四大操作:

[cpp] view plain copy

1. //入队, 这是链式队列的关键  
2. template <typename Type>  
3. void LinkQueue<Type>::push(const Type &data)  
4. {  
5.     if (isEmpty())  
6.     {  
7.         //如果队列为空  
8.         //则队首与队尾指针共同指向一个新构造的对象  
9.         m_front = m_back = new ChainNode(data);  
10.     }  
11.     else  
12.     {  
13.         //首先让队尾的下一位置指向一个新构造的对象  
14.         m_back->next = new ChainNode(data);  
15.         //然后队尾指针后移  
16.         m_back = m_back->next;  
17.     }  
18. }  

[cpp] view plain copy

1. //出队  
2. template <typename Type>  
3. void LinkQueue<Type>::pop()  
4. {  
5.     if (isEmpty())  
6.         throw std::range_error("queue is empty");  
7.   
8.     ChainNode *deleteNode = m_front;  
9.     // 队首指针后移  
10.     m_front = m_front->next;  
11.     delete deleteNode;  
12. }  

[cpp] view plain copy

1. //取队首元素  
2. template <typename Type>  
3. const Type &LinkQueue<Type>::front() const  
4. {  
5.     if (isEmpty())  
6.         throw std::range_error("queue is empty");  
7.   
8.     return (m_front->data);  
9. }  

[cpp] view plain copy

1. //取队尾元素  
2. template <typename Type>  
3. const Type &LinkQueue<Type>::back() const  
4. {  
5.     if (isEmpty())  
6.         throw std::range_error("queue is empty");  
7.   
8.     return (m_back->data);  
9. }  

清空队列与判空操作:

[cpp] view plain copy

1. template <typename Type>  
2. void LinkQueue<Type>::makeEmpty()  
3. {  
4.     while (!isEmpty())  
5.     {  
6.         pop();  
7.     }  
8. }  

[cpp] view plain copy

1. template <typename Type>  
2. bool LinkQueue<Type>::isEmpty() const  
3. {  
4.     return (m_front == NULL);  
5. }  

输出队列所有元素(以做测试):

[cpp] view plain copy

1. template <typename Type>  
2. ostream &operator<<(ostream &os, LinkQueue<Type> &queue)  
3. {  
4.     for (typename LinkQueue<Type>::ChainNode *currentNode = queue.m_front;  
5.             currentNode != NULL;  
6.             currentNode = currentNode->next)  
7.     {  
8.         os << currentNode->data << ' ';  
9.     }  
10.   
11.     return os;  
12. }  

附-测试代码:

[cpp] view plain copy

1. int main()  
2. {  
3.     LinkQueue<int> queue;  
4.     for (int i = 0; i < 10; ++i)  
5.     {  
6.         queue.push(rand()%100);  
7.     }  
8.     cout << queue << endl;  
9.   
10.     cout << queue.front() << endl;  
11.     queue.pop();  
12.     cout << queue.front() << endl;  
13.     cout << queue.back() << endl;  
14.     cout << queue << endl;  
15.   
16.     LinkQueue<char> cQueue;  
17.     cQueue.push('A');  
18.     cout << "cQueue.front = " << cQueue.front() << endl;  
19.     cout << "cQueue.back = " << cQueue.back() << endl;  
20.     cQueue.pop();  
21.     cout << cQueue << endl;  
22.     try  
23.     {  
24.         cout << "cQueue.front = " << cQueue.front() << endl;  
25.         cout << "cQueue.back = " << cQueue.back() << endl;  
26.     }  
27.     catch(const std::exception &e)  
28.     {  
29.         cerr << e.what() << endl;  
30.     }  
31.   
32.     return 0;  
33. }  

原文地址：http://blog.csdn.net/zjf280441589/article/details/42586581