数据结构：队列

栈和队列

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

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

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

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

队列的抽象数据类型定义

ADT  Queue

Data

   队列中元素具有相同类型及先进先出特性，

   相邻元素具有前驱和后继关系

Operation

     InitQueue

        前置条件：队列不存在

        输入：无

        功能：初始化队列

        输出：无

        后置条件：创建一个空队列

 

队列的抽象数据类型定义

DestroyQueue

     前置条件：队列已存在

     输入：无

     功能：销毁队列

     输出：无

     后置条件：释放队列所占用的存储空间

 EnQueue

     前置条件：队列已存在

     输入：元素值x

     功能：在队尾插入一个元素

     输出：如果插入不成功，抛出异常

     后置条件：如果插入成功，队尾增加了一个元素

DeQueue

     前置条件：队列已存在

     输入：无

     功能：删除队头元素

     输出：如果删除成功，返回被删元素值

     后置条件：如果删除成功，队头减少了一个元素

 GetQueue

     前置条件：队列已存在

     输入：无

     功能：读取队头元素

     输出：若队列不空，返回队头元素

     后置条件：队列不变

Empty

     前置条件：队列已存在

     输入：无

     功能：判断队列是否为空

     输出：如果队列为空，返回1，否则，返回0

     后置条件：队列不变

endADT

顺序队列：队列的顺序存储结构

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

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

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

循环队列的声明：

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

}

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

(rear-front+QueueSize)%Queuesize

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;

}

链队列的实现——入队

算法描述：

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;

}

链队列的实现——出队

算法描述：

p=front->next;

front->next=p->next;

delete p;

链队列的实现——出队

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

空间性能:

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

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