队列

一、队列的基本概念

1.队列的定义

       队列只允许在表的一端进行插入，而在表的另一端进行删除。可以理解成超市结账排队。其操作特性是先进先出(First In First Out, FIFO)，为先行先出线性表。

       队头(Front)：允许删除的一端，又称队首。

       队尾(Rear)：允许插入的一端。

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

 

2.队列常见的基本操作

       InitQueue(&Q)：初始化队列，构造一个空队列Q；

       QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false；

       EnQueue(&Q.x)：入队，若队列Q未满，将x加入，使之成为新的队尾；

       DeQueue(&Q,&x)：出队，若队列Q非空，删除队头元素，并用x返回；

       GetHead(Q,&x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

      

 

二、队列的顺序存储结构

1.队列的顺序存储

       队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针front和rear分别指示队头元素和队尾元素的位置。示意图如下图所示：

       队列的顺序存储类型描述如下：      

#define MaxSize 50                 //定义队列中元素的最大个数
typedef struct{
    ElemType data[MaxSize];        //存放队列元素
    int front, rear;               //队头指针和队尾指针
}SqQueue;

       初始状态(队空条件)：Q.front==Q.rear==0；

       进队操作：队不满时，先送值到队尾元素，再将队尾指针加1；

       出队操作：队不空时，先取队头元素值，再将队头指针加1。

       看起来似乎一切都是那么美好，但是会产生假溢出现象！！！！！！这是由于进队操作和出队操作导致的，例如上图中的(c)->(d)结束后如果在进队一个元素，就会报错溢出，但实际上队列还有空位，这就是假溢出。为了解决这个问题，我们引入了循环队列。

 

2.循环队列

       将顺序队列打造成一个环状的空间，即把存储队列元素的表从逻辑上视为一个环，就称为循环队列。如下图示意：

       初始时：Q.front=Q.rear=0；

       队首指针进1：Q.front=(Q.front+1)%MaxSize；

       队尾指针进1：Q.rear=(Q.rear+1)%MaxSize；

       队列长度：(Q.rear+MaxSize-Q.front)%MaxSize；

       出队入队时：指针都按顺时针方向进1。

       因为判断队空和队满的条件都是Q.front==Q.rear，所以我们特殊处理一下，有三种方法可以考虑。

       （1）牺牲一个存储单元来区分队空和队满，就如上面的(d2)，入队时少用一个队列单元，比较常用。约定以“队头指针在队尾指针的下一位置作为队满的标志”。

       队满条件：(Q.rear+1)%MaxSize==Q.front；

       队空条件：Q.front==Q.rear；

       队列中元素个数：(Q.rear-Q.front+MaxSize)%MaxSize。

       （2）类型中增加表示元素个数的数据成员。队空的条件为Q.size==0；队满的条件为Q.size==MaxSize。这两种情况都有Q.front==Q.rear。

       （3）类型中增设tag数据成员，以区分是队满还是队空。tag=0时，若因删除导致Q.front==Q.rear，则为队空；tag=1时，若因插入导致Q.front==Q.rear，则为队满。

 

3.循环队列的操作（牺牲一个存储单元）

（1）初始化      

void InitQueue(SqQueue &Q)
{
    Q.rear=Q.front=0;             //初始化队首、队尾指针
}

 

（2）判队空   

bool isEmpty(SqQueue Q)
{
    if(Q.rear==Q.front)       //队空条件
        return true;
    else
        return false;
}

 

（3）入队    

bool EnQueue(SqQueue &Q, ElemType x)
{
    if((Q.rear+1)%MaxSize==Q.front)          //队满
        return false;
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%MaxSize;               //队尾指针加1取模
    return true;
}

 

（4）出队      

bool DeQueue(SqQueue &Q, ElemType &x)
{
    if(Q.rear==Q.front)                     //队空，报错
        return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;            //队头指针加1取模
    return true;
}

 

三、队列的链式储存结构

1.队列的链式存储

       队列的链式表示称为链队列，是一个同时带有队头指针和队尾指针的单链表。头指针指向队头指针，尾指针指向队尾结点，即单链表的最后一个结点。

       不带头结点的链式队列：

       带头结点的链式队列：

       前面在讨论单链表的时候说过头结点的作为，为了使各个结点的删除和插入操作统一，我们多使用带头结点的链式队列。

       队列的链式存储类型描述如下：      

typedef struct{                   //链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct{                   //链式队列
    LinkNode *front, *rear;       //队列的队头和队尾指针
}LinkQueue;

       当Q.front==NULL且Q.rear==NULL时，链式队列为空。

       用单链表表示的链式队列特别适合于数据元素变动比较大的情形，而且不存在队列满且产生溢出的问题。

 

2.链式队列的基本操作

（1）初始化     

void InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));  //建立头结点
    Q.front->next=NULL;                                  //初始化为空
}

 

（2）判队空

bool IsEmpty(LinkQueue Q)
{
    if(Q.front==Q.rear)         //判断队空
        return true;
    else
        return false;
}

 

（3）入队      

void EnQueue(LinkQueue &Q, ElemType x)
{
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));  //分配空间
    s->data=x;
    s->next=NULL;                                      //创建新结点，插入到链表尾部
    Q.rear->next=s;
    Q.rear=s;
}

 

（4）出队      

bool DeQueue(LinkQueue &Q, ElemType &x)
{
    if(Q.front==Q.rear)                    //空队
        return false;
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)
        Q.rear=Q.front;                    //若原队列中只有一个结点，删除后变空
    free(p);
    return true;
}

 

四、双端队列

       双端队列是指允许两端都可以进行入队和出队操作的队列，如下图所示，其仍为线性结构。将队列的两端分别称为前端和后端，两端都可以入队和出队。

       在双端队列进队时，前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列中前端进的元素的后面。在双端队列出队时，无论是前端还是后端出队，先出的元素排列在后出的元素的前面。

       输出受限的双端队列：允许在一端进行插入和删除，但在另一端只允许插入的双端队列称为输出受限的双端队列。

       输入受限的双端队列：允许在一端进行插入和删除，但在另一端只允许删除的双端队列称为输入受限的双端队列。