数据结构面试之四——队列的常见操作

题注：《面试宝典》有相关习题，但思路相对不清晰，排版有错误，作者对此参考相关书籍和自己观点进行了重写，供大家参考。

四、队列的基本操作

1.用数组构造队列

队列即是满足先进先出的链表。用数组存储的话，同样需要满足队列头front出栈，队列末尾rear入栈。而对于数组来讲，rear和front可以代表数组头和尾。不能简单的固定rear和front的大小为maxSize和0，因为可能出现中间元素为空的现象。所以，对于数组队列来讲，可以想象成环式存储，因为每一次入队后rear+1，每一次出队后front+1。这就需要控制front和rear的大小，每一次修改只要满足front=（front+1）%maxSize，rear=（rear+1）%maxSize即可满足要求。

       同样需要注意：入队操作前先判定队列是否已经满；出队操作前先判定队列是否为空。

template<typename Type>class arrQueue{public:       arrQueue(intnSize=100);       ~arrQueue();       arrQueue(constarrQueue<Type>& copyQueue);       arrQueue&operator=(const arrQueue<Type>& otherQueue);        voidinitializeQueue();       void destroyQueue();       bool isQueueEmpty();       bool isQueueFull();       void addQueue(constType& item);       void deQueue(Type&deletedItem); private:       int maxSize;       int rear;       int front;       Type* list;}; template<typename Type>arrQueue<Type>::arrQueue(int nSize=100){       if(nSize < 0)       {              nSize = 100;              list = newType[nSize];              front = 0;              rear = 0;              maxSize = 100;       }       else       {              list = newType[nSize];              front = 0;              rear = 0;              maxSize =nSize;       }} template<typename Type>arrQueue<Type>::~arrQueue(){       if(!list)       {              delete[]list;                  //注意数组的删除，为delete []list;              list = NULL;       }} template<typename Type>arrQueue<Type>::arrQueue(const arrQueue<Type>©Queue){       maxSize =copyQueue.maxSize;       front =copyQueue.front;       rear = copyQueue.rear;       list = newType[maxSize];            //注意需要自定义大小,容易出错.       for( int i = 0; i <rear; i++)       {              list[i] =copyQueue.list[i];       }} template<typename Type>arrQueue<Type>& arrQueue<Type>::operator=(constarrQueue<Type>& otherQueue){       if(this ==&otherQueue)       {              cout <<"can't copy oneSelf!" << endl;              return *this;       }       else       {              if(maxSize !=otherQueue.maxSize)              {                     cout<< "The Size of two Queue are not equal!" << endl;                     return*this;              }              else              {                     maxSize= otherQueue.maxSize;                     front =otherQueue.front;                     rear =otherQueue.rear;                     for( inti = 0; i < rear; i++)                     {                            list[i]= otherQueue.list[i];                     }//endfor                     return*this;              }       }//end else} template<typename Type>void arrQueue<Type>::initializeQueue(){       destroyQueue();} template<typename Type>void arrQueue<Type>::destroyQueue(){       front = 0;       rear = 0;} //栈空的判定标志rear==front[初始]template<typename Type>bool arrQueue<Type>::isQueueEmpty(){       return (rear ==front);} //空余1位作为判定位,可以把存储结构想象成环!//注意栈满的判定：1.保证空间都被占用;//2.保证rear的下一个位置=front即为满。template<typename Type>bool arrQueue<Type>::isQueueFull(){       return((rear+1)%maxSize == front); } template<typename Type>void arrQueue<Type>::addQueue(const Type& item){       if(!isQueueFull())       {              list[rear] =item;              rear =(rear+1)%maxSize;              cout << item<< " was added to Queue!" << endl;       }       else       {              cout <<"The Queue was already Full!" << endl;       }} template<typename Type>void arrQueue<Type>::deQueue(Type& deletedItem){       if(!isQueueEmpty())       {              deletedItem =list[front];              front =(front+1)%maxSize;                  //注意此处的判定!              cout <<deletedItem << " was deleted from Queue!" << endl;       }       else       {              cout <<"The Queue was already Empty!" << endl;       }}

2.队列采用链表链式存储结构

注意：1）此时的front和rear都变成了指针，front变成了头结点指针，而rear变成了尾节点的指针。2）此处的front和rear类似于链表操作中的first和last。3）入队实现主要在队列尾部实现，需要调整rear指针的指向；而出队操作主要在队头实现，需要调整front指针的指向。

template<typename Type>struct nodeType{       Type info;       nodeType* link;}; template<typename Type>class linkedQueue{public:       linkedQueue();       ~linkedQueue();       linkedQueue(constlinkedQueue<Type>&);       linkedQueue&operator=(const linkedQueue<Type>&);        voidinitializeQueue();       void destroyQueue();       bool isQueueEmpty()const;       bool isQueueFull()const;       void addQueue(constType& item);       void deQueue(Type&poppedItem);       void nodeCount(); private:       nodeType<Type>*rear;       nodeType<Type>*front;       int count;         //统计节点个数}; template<typename Type>linkedQueue<Type>::linkedQueue(){       count = 0;       front = NULL;       rear = NULL;} template<typename Type>linkedQueue<Type>::~linkedQueue(){       while( front != NULL )       {              nodeType<Type>*tempNode = new nodeType<Type>;              tempNode =front;              front =front->link;               deletetempNode;       }       //注意rear的清空       rear = NULL;} template<typename Type>linkedQueue<Type>::linkedQueue(constlinkedQueue<Type>& copyQueue){       if(copyQueue.front !=NULL)       {              nodeType<Type>*current;              nodeType<Type>*first;              nodeType<Type>*newNode;               front = newnodeType<Type>;              front->info= copyQueue.front->info;          //此处的top不能直接用，内存报错！              front->link= copyQueue.front->link;               first =front;                        //first跟进当前链表...              current =copyQueue.front->link;      //current跟进copy链表...              while( current!= NULL)              {                     newNode= new nodeType<Type>;                     newNode->link= current->link;                     newNode->info= current->info;                      first->link= newNode;                     first =newNode;                     current= current->link;              }//end while              rear = current;              count =copyQueue.count;       }//end if       else       {              front = NULL;              rear = NULL;              count = 0;       }} template<typename Type>linkedQueue<Type>& linkedQueue<Type>::operator=(constlinkedQueue<Type>& otherQueue){       //1避免自身赋值       if(this ==&otherQueue)       {              cout <<"Can't copy oneself!" << endl;              return *this;       }       //2其他       else       {              if(front !=NULL)              {                     destroyQueue();              }              if(otherQueue.front!= NULL)              {                     nodeType<Type>*current;                     nodeType<Type>*first;                     nodeType<Type>*newNode;                      front =new nodeType<Type>;                     front->info= otherQueue.front->info;                     front->link= otherQueue.front->link;                     first =front;                        //first跟进当前链表...                     current= otherQueue.front->link;     //current跟进copy链表...                     while(current != NULL)                     {                            newNode= new nodeType<Type>;                            newNode->link= current->link;                            newNode->info= current->info;                             first->link= newNode;                            first= newNode;                            current= current->link;                     }//endwhile                     rear =current;                     count =otherQueue.count;              }//end if              else              {                     front =NULL;                     rear =NULL;                     count =0;              }              return *this;       }} template<typename Type>void linkedQueue<Type>::initializeQueue(){       destroyQueue();} template<typename Type>void linkedQueue<Type>::destroyQueue(){       count = 0;       //注意此处的销毁工作：需要循环判定!       while(front != NULL)       {              nodeType<Type>*temp = new nodeType<Type>;              temp = front;              front =front->link;       }        rear = NULL;} template<typename Type>bool linkedQueue<Type>::isQueueEmpty() const{       return (front ==NULL);} template<typename Type>bool linkedQueue<Type>::isQueueFull() const //空间非固定，动态申请!{       return false;} template<typename Type>void linkedQueue<Type>::addQueue(const Type& item){       if(!isQueueFull())       {              nodeType<Type>*newNode = new nodeType<Type>;              newNode->info= item;              newNode->link= NULL;               if(front ==NULL)              {                     front =newNode;                     rear =newNode;              }              else              {                     rear->link= newNode;                     rear =newNode;              }              count++;              cout <<item << " was pushed!" << endl;       }} template<typename Type>void linkedQueue<Type>::deQueue(Type& deletedItem){       if(!isQueueEmpty())       {              nodeType<Type>*temp = new nodeType<Type>;              temp = front;              deletedItem =front->info;              front =front->link;               count--;              cout <<deletedItem << " was popped!" << endl;              delete temp;       }} template<typename Type>void linkedQueue<Type>::nodeCount(){       cout <<"nodeCount = " << count << endl;} 

3.用栈实现队列

注意栈是先进后出，而用两个栈：栈1先进后出，栈2在栈1的基础上先进后出，就能实现了先进先出。

注意：入队addtoQueue要保证将元素放入到栈1中；而对于出队deQueue要保证将栈1的全部元素出栈pop，然后再全部入栈2，最后执行出栈2操作即可。

#include"linkedStack.h"template<typename Type>class stackedQueue{public:       stackedQueue();       ~stackedQueue();        void addQueue(Type item);       void deQueue(Type deletedItem);             bool isQueueEmpty();       bool isQueueFull(); private:       nodeType<Type>* front;       nodeType<Type>* rear;       linkedStack<Type>* firstStack;       linkedStack<Type>* secondStack;       int nodeCnt;    //记录节点个数}; template<typename Type>stackedQueue<Type>::stackedQueue(){       front = NULL;       rear = NULL;    nodeCnt = 0;             firstStack = new linkedStack<Type>;       secondStack = new linkedStack<Type>;} template<typename Type>stackedQueue<Type>::~stackedQueue(){       while(front != NULL)       {              nodeType<Type>* temp;              temp = front;              front = front->link;       }       rear = NULL;       if(firstStack != NULL)       {              delete firstStack;              firstStack = NULL;       }       if(secondStack != NULL)       {              delete secondStack;              secondStack = NULL;       }} template<typename Type>voidstackedQueue<Type>::addQueue(Type item){       if(!isQueueFull())       {              nodeCnt++;              firstStack->push(item);        //单个入栈1              cout << item << " was added toQueue!" << endl;       }} template<typename Type>voidstackedQueue<Type>::deQueue(Type deletedItem){       if(!isQueueEmpty())       {              while(!firstStack->isStackEmpty())              {                     firstStack->pop(deletedItem);              //全部出栈1                     if(!firstStack->isStackFull())                     {                            secondStack->push(deletedItem);       //全部入栈2                     }              }              if(!secondStack->isStackEmpty())              {                     secondStack->pop(deletedItem);            //单个出栈2              }              cout << deletedItem << " was out ofQueue!" << endl;              nodeCnt--;       }} template<typename Type>boolstackedQueue<Type>::isQueueEmpty(){       return (nodeCnt == 0);} template<typename Type>boolstackedQueue<Type>::isQueueFull(){       return false;}

第四节结束。