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

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

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

四、队列的基本操作

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;
 }