队列

队列的逻辑结构

队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。

空队列：不含任何数据元素的队列。

允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。

队列的操作特性：先进先出(FIFO,LILO)

队列的顺序存储结构及实现

队头指针和队尾指针：

1. 队头指针指向队列中的第一个元素之前的元素，队尾指针指向队列中的最后一个元素
2. 队头指针指向队列中的第一个元素，队尾指针指向队列中的最后一个元素的后一个位置

假溢出：当元素被插入到数组中下标最大的位置上之后，队列的空间就用尽了，尽管此时数组的低端还有空闲空间，这种现象叫做假溢出。

循环队列：将存储队列的数组头尾相接。

队空：front==rear

队满：front==rear

判断队空队满：

方法一：附设一个存储队列中元素个数的变量num，当num=0时队空，当num=QueueSize时为队满；

方法二：修改队满条件，浪费一个元素空间，队满时数组中只有一个空闲单元；

方法三：设置标志flag，当front=rear且flag=0时为队空，当front=rear且flag=1时为队满。

队满的条件：(rear+1) mod QueueSize==front

循环队列类的声明：

const int QueueSize=100;

template <class T>   

class CirQueue{

  public:

      CirQueue( )；

      ~ CirQueue( )；

      void EnQueue(T x);

     T DeQueue( );            

     T GetQueue( );

     bool Empty( ){

      if (rear==front) return true;

       return false;

   }；

  private:

     T data[QueueSize];  

     int front, rear;

};

循环队列的实现——入队

template <class T>

 void CirQueue<T>::EnQueue(T x)

 {

   if ((rear+1) % QueueSize ==front) throw "上溢";

   rear=(rear+1) % QueueSize;   

   data[rear]=x;                

 }

循环队列的实现——出队

template <class T>

T CirQueue<T>::DeQueue( )

{

     if (rear==front) throw "下溢";

     front=(front+1) % QueueSize;

     return data[front];

}

循环队列的实现——读队头元素

template <class T>

T CirQueue<T>::GetQueue( )

{

    if (rear==front) throw "下溢";

    i=(front+1) % QueueSize; 

    return data[i];

}

循环队列的实现——队列长度

template <class T>

int CirQueue<T>::GetLength( )

{

    if (rear==front) throw "下溢";

    len=(rear-front+ QueueSize) % QueueSize; 

    return len;

}

队列的链接存储结构及实现

链队列类的声明：

template <class T>

class LinkQueue

{  

  public:

      LinkQueue( );    

      ~LinkQueue( );

      void EnQueue(T x);

      T DeQueue( );      

      T GetQueue( )；

      bool Empty( )；

  private:

      Node<T> *front, *rear;

};

链队列的实现——构造函数

操作接口： LinkQueue( );

算法描述：

template <class T>

LinkQueue<T>::LinkQueue( )

{

     front=new Node<T>;

     front->next=NULL; 

     rear=front;

}

链队列的实现——入队

算法描述（有头结点）：

s->next=NULL;

rear->next=s;

rear=s;

算法描述（无头结点）：

s->next=NULL;

rear=s;

front=s;

链队列的实现——入队

template <class T>

void LinkQueue<T>::EnQueue(T x)

{

    s=new Node<T>;

    s->data=x;

    s->next=NULL;

    rear->next=s;

    rear=s;

}

链队列的实现——出队

template <class T>

T LinkQueue<T>::DeQueue( )

{

     if (rear==front) throw "下溢";

     p=front->next;

     x=p->data;

     front->next=p->next;       

     delete p;

     if (front->next==NULL) rear=front;  

     return x;

}

循环队列和链队列的比较

时间性能:

循环队列和链队列的基本操作都需要常数时间O (1)。

空间性能:

循环队列：必须预先确定一个固定的长度，所以有存储元素个数的限制和空间浪费的问题。

链队列：没有队列满的问题，只有当内存没有可用空间时才会出现队列满，但是每个元素都需要一个指针域，从而产生了结构性开销。