栈和队列——队列

一、队列的逻辑结构

队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。
空队列：不含任何数据元素的队列。
允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。

抽象数据类型定义

ADT Queue
Data
队列中元素具有相同类型及先进先出特性，
相邻元素具有前驱和后继关系
Operation：
InitQueue
前置条件：队列不存在
输入：无
功能：初始化队列
输出：无
后置条件：创建一个空队列

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

EnQueue
前置条件：队列已存在
输入：元素值x
功能：在队尾插入一个元素
输出：如果插入不成功，抛出异常
后置条件：如果插入成功，队尾增加了一个元素

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

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

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

endADT

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

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

二、 循环队列

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

构建函数

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

入队

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)。

空间性能:

循环队列：必须预先确定一个固定的长度，所以有存储元素个数的限制和空间浪费的问题。
链队列：没有队列满的问题，只有当内存没有可用空间时才会出现队列满，但是每个元素都需要一个指针域，从而产生了结构性开销。