LinkQueue（链队列）

关于Node.h，请参考LinkStack

 #include"Node.h"
 template<typename ElemType>
 class LinkQueue
 {
 protected:
     Node<ElemType> *front,*rear;
     int count;
 public:
     LinkQueue();
     virtual ~LinkQueue();
     int Length()const;
     bool Empty()const;
     void Clear();
     bool Inqueue(const ElemType &e);
     bool Outqueue(ElemType &e);
     bool GetHead(ElemType &e) const;
     void Traverse(void(*visit)(const ElemType &))const;
     LinkQueue(const LinkQueue<ElemType> &copy);
     LinkQueue<ElemType> &operator=(const LinkQueue<ElemType> &copy);
 };
 template<typename ElemType>
 //构造一个空队列；
 LinkQueue<ElemType>::LinkQueue()
 {
     front=rear=new Node<ElemType>;
     count=;
 }
 template<typename ElemType>
 //虚虚构函数
 LinkQueue<ElemType>::~LinkQueue()
 {
     Clear();
 }
 template<typename ElemType>
 //返回队列长度
 int LinkQueue<ElemType>::Length()const
 {
     return count;
 }
 template<typename ElemType>
 //判断队列为空
 bool LinkQueue<ElemType>::Empty()const
 {
     return count==;
 }
 template<typename ElemType>
 //清除队列
 void LinkQueue<ElemType>::Clear()
 {
     ElemType tmpElem;
     while(!Empty())
         Outqueue(tmpElem);
 }
 template<typename ElemType>
 //队尾进队
 bool LinkQueue<ElemType>::Inqueue(const ElemType &e)
 {
     Node<ElemType> *tmpPtr=new Node<ElemType>(e);
     rear->next=tmpPtr;
     rear=tmpPtr;
     count++;
     return true;

 }
 template<typename ElemType>
 //队头出队
 bool LinkQueue<ElemType>::Outqueue(ElemType &e)
 {
     if(!Empty())
     {
         Node<ElemType> *tmpPtr=front->next;
         e=tmpPtr->data;
         front->next=tmpPtr->next;
         if(rear==tmpPtr)
             rear=front;
         delete tmpPtr;
         count--;
         return true;
     }
     else
         return false;
 }
 template<typename ElemType>
 //返回队头元素
 bool LinkQueue<ElemType>::GetHead(ElemType &e) const
 {
     if(!Empty())
     {
         e=front->next->data;
         return true;
     }
     else
         return false;

 }
 template<typename ElemType>
 //visit
 void LinkQueue<ElemType>::Traverse(void(*visit)(const ElemType &))const
 {
     for(Node<ElemType> *tmpPtr=front->next;tmpPtr;tmpPtr=tmpPtr->next)
         (*visit)(tmpPtr->data);
 }
 template<typename ElemType>
 //复制构造
 LinkQueue<ElemType>::LinkQueue(const LinkQueue<ElemType> &copy)
 {
     rear=front=new Node<ElemType>;
     count=;
     for(Node<ElemType> *tmpPtr=copy.front->next;tmpPtr!=NULL;tmpPtr=tmpPtr->next)
         Inqueue(tmpPtr->data);
 }
 template<typename ElemType>
 //重载=operator
 LinkQueue<ElemType> &LinkQueue<ElemType>::operator=(const LinkQueue<ElemType> &copy)
 {
     if(&copy!=this)
     {
         Clear();
         for(Node<ElemType> *tmpPtr=copy.front->next;tmpPtr!=NULL;tmpPtr=tmpPtr->next)
             Inqueue(tmpPtr->data);
         return *this;
     }

 }