队列的链表形式的实现，实现了部分功能，该链表不包含头结点

本文链接：https://blog.csdn.net/qq_28633157/article/details/49246129
//节点的头文件
#ifndef LINKNODE_H
#define LINKNODE_H


#include
   
   
    
    
using namespace std;
//节点的头文件
template
    
    
     
     
class LinkNode{

public:
	T data;
	LinkNode* link;
	LinkNode(){
		//默认构造函数
	}
	LinkNode(T data, LinkNode* str = NULL) :data(data), link(str){

	}

};


#endif

//链表实现的头文件
#ifndef ARRAYQUEUE_H
#define ARRAYQUEUE_H

#include
     
     
      
      
#include"LinkNode.h"
#include
      
      
       
       
#include
       
       
         using namespace std; template 
        
          class ArrayQueue{ private: LinkNode 
         
           * front; LinkNode 
          
            * rear; public: ArrayQueue();//默认构造函数 ArrayQueue(const ArrayQueue& str);//拷贝构造函数 ~ArrayQueue(); void Clear(); void EnQueue(const T value);//在尾部追加元素 void DeQueue();//删除队头元素 T ReQueue();//返回队头元素 T ReAndDeQueue();//删除并返回队头元素 //bool ifFull();//在链表类型的队列中不存在满栈情况 bool Empty();//是否空栈 int Length(); void Print(); void Sort(); }; template 
           
             ArrayQueue 
            
              ::ArrayQueue() { //因为假定该链表不含头结点，所以在默认构造函数中不生成任何节点 front = NULL; rear = NULL; } template 
             
               ArrayQueue 
              
                ::ArrayQueue(const ArrayQueue& str) { int count = str.Length(); LinkNode 
               
                 * ptr = str->front; if (count) LinkNode 
                
                  * p = front = new LinkNode 
                 
                   (ptr->data); ptr = ptr->link; for (int i = 1; i < count; i++) { p->link = new LinkNode 
                  
                    (ptr->data); p = p->link; ptr = ptr->link; } ptr->link = NULL; rear = ptr; } template 
                   
                     ArrayQueue 
                    
                      ::~ArrayQueue() { Clear(); } template 
                     
                       void ArrayQueue 
                      
                        ::Clear() { LinkNode 
                       
                         * p = front; if (Empty()) { //如果是空栈，则不进行任何操作 return; } while (p) { p = p->link; delete front; front = p; } } template 
                        
                          void ArrayQueue 
                         
                           ::EnQueue(const T value) { //在队列中添加元素，直接在队尾进行添加 if (front == NULL) { front = new LinkNode 
                          
                            (value); rear = front; } else { LinkNode 
                           
                             * p = rear; p->link = new LinkNode 
                            
                              (value); p = p->link; p->link = NULL; rear = p; } } template 
                             
                               void ArrayQueue 
                              
                                ::DeQueue() { //删除队头元素，但不返回任何值 LinkNode 
                               
                                 * p = front; if (Empty()) { //如果是空栈，则不进行删除行为 return; } p = p->link; delete front; front = p; } template 
                                
                                  T ArrayQueue 
                                 
                                   ::ReQueue() { T tempData; if (Empty()) { return -1; } tempData = front->data; return tempData; } template 
                                  
                                    T ArrayQueue 
                                   
                                     ::ReAndDeQueue() { if (Empty()) { return -1; } T tempData = ReQueue(); DeQueue(); return tempData; } template 
                                    
                                      bool ArrayQueue 
                                     
                                       ::Empty() { if (front != NULL) return false; return true; } template 
                                      
                                        int ArrayQueue 
                                       
                                         ::Length() { if (Empty()) { return 0; } int count = 0; LinkNode 
                                        
                                          * p = front; while (p) { p = p->link; count++; } return count; } template 
                                         
                                           void ArrayQueue 
                                          
                                            ::Print() { if (Empty()) { return; } LinkNode 
                                           
                                             * p = front; while (p) { cout << p->data << " "; p = p->link; } cout << endl; } template 
                                            
                                              void ArrayQueue 
                                             
                                               ::Sort() { //在该排序过程中借助了vector中的sort()函数进行排序 vector 
                                              
                                                str; LinkNode 
                                               
                                                 * p = front; while (p) { str.push_back(p->data); p = p->link; } sort(str.begin(),str.end()); p = front; vector 
                                                
                                                  ::const_iterator iter = str.begin(); for (; iter != str.end(); iter++) { p->data = *iter; p = p->link; } } #endif //主函数 #include"ArrayQueue.h" int main(int argc, char argv[]) { ArrayQueue 
                                                 
                                                   queue; queue.EnQueue(4); queue.EnQueue(6); queue.EnQueue(9); queue.EnQueue(7); queue.EnQueue(1); queue.EnQueue(0); queue.EnQueue(2); queue.EnQueue(5); queue.EnQueue(8); queue.Print(); int data = queue.ReQueue(); cout << data << endl; queue.DeQueue(); queue.Print(); int temp = queue.ReAndDeQueue(); cout << temp << endl; queue.Print(); return 0; }