链式队列基本操作之code_legend



#include <iostream>
using namespace std;
typedef int ElemType;

class QNode{
      public:

      ElemType data;/*数据域*/
      QNode * next;
      public :
      /*构造函数初始化各个数据成员*/
      QNode(ElemType data1,QNode* next1){
      data=data1;
      next=next1;
      }

      QNode(){next=NULL;}
};

class LinkQueue{
      public:
      QNode* front;
      QNode* rear;
      public:
      /*构造函数，初始化数据成员*/
      LinkQueue(){
      QNode* pnode=new QNode;
      front=rear=pnode;
      }

      /*判断是否为空*/
      bool isEmpty(){
      if(front==rear)
      return true;
      else return false;
      }

      /*进队列*/
      bool en_queue(ElemType elem){

      QNode* newNode=new QNode(elem,NULL);
      rear->next=newNode;/*rear为最后一个节点的指针*/
      rear=newNode;/*更新rear*/
      return true;
      }

      /*出队列*/
      bool de_queue(ElemType & elem){
            if(isEmpty()) return false;
            QNode * firstNode=front->next;/*取得第一个节点*/
            elem=firstNode->data;/*取数据域保存*/
            front->next=firstNode->next;

            if(firstNode->next==NULL){
            rear=front;/*如果只有一个节点，则保证出队后对空。即rear=front*/
            }
            delete firstNode;
            return true;
      }
      /*获取队头*/
      bool getFront(ElemType & elem){
      if(isEmpty()) return false;
      elem=front->next->data;/*取第一个节点 的数据域*/
      return true;
      }

      /*清空队列*/
      void clear_queue(){
             while(front){
             rear=front->next;
             delete front;
             front=rear;
             }
      }

      /*析构函数*/
      ~LinkQueue(){
      clear_queue();
      }

};
int main()
{
      LinkQueue liqueue;
      liqueue.en_queue(3);
      liqueue.en_queue(4);
      liqueue.en_queue(2);
      liqueue.en_queue(6);

      ElemType elem;
      liqueue.getFront(elem);
      cout<<elem<<endl;

      while(!liqueue.isEmpty()){

      liqueue.de_queue(elem);
      liqueue.getFront(elem);
      cout<<elem<<endl;

      }

      if(liqueue.isEmpty())
      cout<<"is empty "<<endl;

    cout << "Hello world!" << endl;
    return 0;
}
--------------------------------------------------------------
版本二：

/*LinkQueue.h*/

//LinkQueue.h
#ifndef LINKQUEUE_H
#define LINKQUEUE_H

template <class T>
struct Node
{
      T data;
      Node<T> *next;  //此处<T>也可以省略
};

template <class T>
class LinkQueue
{
public:
    LinkQueue( );          //构造函数，初始化一个空的链队列
    ~LinkQueue( );      //析构函数，释放链队列中各结点的存储空间
    void EnQueue(T x);  //将元素x入队
    T DeQueue( );       //将队头元素出队
    T GetQueue( );     //取链队列的队头元素
    bool Empty( );     //判断链队列是否为空
private:
    Node<T> *front, *rear;  //队头和队尾指针，分别指向头结点和终端结点
};

#endif;
--------------------------------
/*LinkQueue.cpp*/

#include "LinkQueue.h"

/*
 * 前置条件：队列不存在
 * 输    入：无
 * 功    能：初始化队列
 * 输    出：无
 * 后置条件：创建一个空队列
 */

template <class T>
LinkQueue<T>::LinkQueue( )
{
 Node <T> *s;
 s=new Node<T>;
 s->next=NULL;
 front=rear=s;
}

/*
 * 前置条件：队列存在
 * 输    入：无
 * 功    能：销毁队列
 * 输    出：无
 * 后置条件：释放队列所占用的存储空间
 */

template <class T>
LinkQueue<T>::~LinkQueue( )
{
 while(front)
 {
  Node <T> *p;
  p=front->next;
        delete front;
     front=p;
 }
}

/*
 * 前置条件：队列已存在
 * 输    入：元素值s
 * 功    能：在队尾插入一个元素
 * 输    出：无
 * 后置条件：如果插入成功，队尾增加了一个元素
 */

template <class T>
void LinkQueue<T>::EnQueue(T x)
{
 Node<T> *s;
    s=new Node<T>;
    s->data=x;          //申请一个数据域为x的结点s
    s->next=NULL;
    rear->next=s;       //将结点s插入到队尾
    rear=s;
}

/*
 * 前置条件：队列已存在
 * 输    入：无
 * 功    能：删除队头元素
 * 输    出：如果删除成功，返回被删元素值，否则，抛出删除异常
 * 后置条件：如果删除成功，队头减少了一个元素
 */

template <class T>
T LinkQueue<T>::DeQueue()
{   
 Node <T> *p; int x;
    if (rear==front) throw "下溢";
    p=front->next;
 x=p->data;                       //暂存队头元素
    front->next=p->next;             //将队头元素所在结点摘链
    if (p->next==NULL) rear=front;   //判断出队前队列长度是否为1
    delete p;
    return x;
}

/*
 * 前置条件：队列已存在
 * 输    入：无
 * 功    能：读取队头元素
 * 输    出：若队列不空，返回队头元素
 * 后置条件：队列不变
 */

template <class T>
T LinkQueue<T>::GetQueue()
{
    if (front!=rear)
  return front->next->data;
}

/*
 * 前置条件：队列已存在
 * 输    入：无
 * 功    能：判断队列是否为空
 * 输    出：如果队列为空，返回1，否则，返回0
 * 后置条件：队列不变
 */

template <class T>
bool LinkQueue<T>::Empty( )
{
    if(front==rear)
  return 1;
    else
  return 0;
}