数据结构——队列

• 队列

一、抽象数据类型队列的定义

定义：只能在 表的一端（队尾）进行插入，在另一端（队头）进行删除运算的线性表。

逻辑结构：与线性表相同，仍为一对一关系。

存储结构：用顺序队列或链队存储均可。

运算规则： 先进先出（FIFO）

实现方式：关键是编写入队和出队函数，具体实现依顺序队或链队的不同而不同。

队列的抽象数据类型：

ADT Queue{

数据对象：

数据关系：

基本操作：

(1) InitQueue (&Q)         //构造空队列

(2)DestroyQueue (&Q)   //销毁队列

(3) ClearQueue (&S)        //清空队列

          (4) QueueEmpty(S)          //判空. 空=TRUE,

          (5) QueueLength(Q)        //取队列长度

          (6) GetHead (Q,&e)         //取队头元素,

          (7) EnQueue (&Q,e)        //入队列

          (8) DeQueue (&Q,&e)     //出队列

          (9) QueueTraverse(Q,visit())       //遍历

}ADT Queue

二、链队列——队列的 链式表示和实现

链队列：用 链表表示的队列（队列的链式表示），需要两个分别指向队头和队尾的 指针（头指针和尾指针）才能唯一确定。

队列的链式存储结构：

typedef struct QNode{

   QElemType   data;

   struct Qnode  *next;

}Qnode, *QueuePtr

typedef struct {

   QueuePtr  front;

           //队头指针  

   QueuePtr  rear;

           //队尾指针

}LinkQueue;

出队列和入队列：

基本操作的算法描述：

Status InitQueue (LinkQueue &Q){

//构造一个空队列，对应图(a)

   Q.front=Q.rear=(QueuePtr) malloc(sizeof(QNode));

    if(!Q.front) exit(OVERFLOW);

    Q.front->next=NULL;

     return OK;

}

Status DestroyQueue (LinkQueue &Q){

//销毁队列Q

   while(Q.front){

      Q.rear=Q.front->next;

      free(Q.front);

      Q.front=Q.rear;  

   }   

   return OK;

}

Status EnQueue(LinkQueue &Q,QElemType e){

//插入元素e为新的队尾元素，对应图(b)

    p=(QueuePtr)malloc(sizeof(QNode));

    if(!p) exit(OVERFLOW);

    p->data=e;

    p->next=NULL;

    Q.rear->next=p;

    Q.rear=p;

    return OK;

}

Status DeQueue (LinkQueue &Q,QElemType &e){

//若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；

   if(Q.front==Q.rear) return ERROR;

   p=Q.front->next;

   e=p->data;

   Q.front->next=p->next;

   if(Q.rear==p) Q.rear=Q.front;

   delete p;

   return OK;

}

一般情况下，删除队列头元素时仅需修改头结点中的指针，但当队列中最后一个元素被删除之后，队列尾指针也丢失了，因此需对队尾指针进行重新赋值（指向头结点）

三、循环队列——队列的 顺序表示和实现

1.顺序队列的缺点：

一开始的时候一个空队：

front=rear=0

使用一维数组base[M]表示

空队标志：front= =rear

入队：base[rear++]=x;

出队：x=base[front++];

当数组的大小为M时：

(1)front=0

rear=M时

再入队— 真溢出

(2)front¹0

rear=M时

再入队— 假溢出

2.解决方法：使用 循环队列

base[0]接在base[M-1]之后

若rear+1==M

则令rear=0;

实现：利用“模”运算

入队：

  base[rear]=x;

  rear=(rear+1)%M;

出队：

  x=base[front];

  front=(front+1)%M;

如果用户的应用程序中设有循环队列，则必须为它设定一个最大队列长度；若用户无法预估所用队列的最大长度，则宜采用链。

队列的链式存储结构：

#define MAXSIZE  100   //最大队列长度

Typedef struct {

   QElemType *base;  //初始化的动态分配存储空间

   int  front;            //头指针  

   int  rear;             //尾指针

}SqQueue;

Status InitQueue(SqQueue &Q){

        //构造一个空队列Q

Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType);   //确定其大小

if(!Q.base)exit(OVERFLOW);

return OK;

}

int QueueLength (SqQueue Q){

//返回Q的元素个数，即队列长度

return(Q.rear-Q.front+MAXQSIXE)%MAXQSIZE;  //存在队尾下标可能小于对头的的情况

}

Status EnQueue (SqQueue &Q,QElemType e){

//插入元素e为Q的新的队尾元素

if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;   //队列满 

    Q.base[Q.rear]=e;

    Q.rear=(Q.rear+1)%MAXQSIZE;

     return OK;

}

Status DeQueue (LinkQueue &Q,QElemType &e){

//若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；

   if(Q.front==Q.rear)         

          return ERROR;

   e=Q.base[Q.front];

   Q.front=(Q.front+1)%MAXQSIZE;

   return OK;

}