数据结构—队列(Queue)

• 队列的定义--Queue

队列是只允许在表的队尾插入,在表的队头进行删除。队列具有先进先出的特性(FIFO, First In First Out)。

• 队列提供了下面的操作

     q.empty()               如果队列为空返回true，否则返回false
     q.size()                返回队列中元素的个数
     q.pop()                 删除队列首元素但不返回其值
     q.front()               返回队首元素的值，但不删除该元素
     q.push()                在队尾压入新元素
     q.back()                返回队列尾元素的值，但不删除该元素

• 队列的实现

下面是用C++实现的一个队列结构的源码(链表)

 #pragma once
 #include<iostream>
 #include<assert.h>
 using namespace std;
 template<typename T>
 class Queue
 {
 public:
     Queue()
         :pHead(NULL)
         , pTail(NULL)
     {}
     Queue(const QueueNode<T>& q)
     {
         QueueNode<T>*Node = q.pHead;
         while (Node)
         {
             Push(Node->data);
             Node = Node->next;
         }
     }
     ~Queue()
     {
         QueueNode<T> *Node = pHead;
         while (Node)
         {
             QueueNode<T>*Del = Node;
             Node = Node->next;
             delete Del;
         }
         pHead = NULL;
         size = ;
     }
     QueueNode<T>& operator = (const QueueNode<T>& q)
     {
         if (this != &q)
         {
            Node<T> *pNode = other._pHead;
             while (NULL != pNode)
             {
                 Push(pNode->_data);
                 pNode = pNode->_pNext;
             }
         }

         return *this;
     }
     void Push(const T &data)
     {
         if (pHead == NULL)
         {
             pTail = pHead = new QueueNode<T>(data);
         }
         else
         {
             pTail ->next = new QueueNode<T>(data);
             pTail = pTail->next;
         }
     }
     void Pop()
     {
         assert(NULL != pHead);
         if (pHead == pTail)
         {
             delete pHead;
             pHead = pTail = NULL;
         }
         else
         {
             QueueNode<T>*Del = pHead;
             pHead = pHead->next;
             delete Del;
         }
     }
     bool Empty()
     {
         return pHead == NULL;
     }
     T& Fornt()
     {
         assert(pHead);

         return pHead->data;
     }

     T& Back()
     {
         assert(pTail);

         return pTail->data;
     }
     size_t Size()
     {
         while (pHead != NULL)
         {
             size++;
             pHead = pHead->next;
         }
         return size;
     }
     void Print()
     {
         QueueNode<T>*cur = pHead;
         while (cur)
         {
             cout << cur->data << "->";
             cur = cur->next;
         }
         cout << "NULL";
     }
 protected:
     QueueNode<T>* _BuyNode(const T& data)
     {
         return new QueueNode<T>(data);
     }
 protected:
     QueueNode<T>* pHead;
     QueueNode<T>* pTail;
     size_t size;
 };
 void main()
 {
     Queue<int> q;
     q.Push();
     q.Push();
     q.Push();
     q.Pop();
     q.Print();
     cout<<q.Size();
     cout<<q.Fornt();
     cout << q.Back();
     system("pause");

 }