数据结构复习—队列

1. 队列的基本概念

1. 队列的定义

队列（Queue）：队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。其操作特点是先进先出（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。

2. 队列的顺序存储结构

1. 队列的顺序存储

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

队列的顺序存储类型可描述为

#define MaxSize 50
typedef struct {
    ElemType data[MaxSize];
    int front,rear;
} SqQueue;

初始状态（队空条件）：Q.front == Q.rear == 0。
进队操作：队不满时，先送值到队尾元素，再将队尾指针加1。
出队操作：队不空时，先取队头元素值，再将队头指针加1。

2. 循环队列

将顺序队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上看出一个坏，称为循环队列。当队首指针Q.front=MaxSize-1后，再前进一个位置就自动到0，这可以利用除法取余运算（%）来实现。
初始时：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。
循环队列出入队示意图如图所示。

为了区分队空还是队满的情况，有三种处理方式：
1）牺牲一个单元来区分队空和队满，入队时少用一个队列单元，这是一种较为普遍的做法，约定以“队头指针在队尾指针的下一位置作为队满的标志”。
队满条件为：(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(&Q) {
    Q.rear=Q.front=0;
}

（2）判队空

bool isEmpty(Q) {
    if(Q.rear==Q.front) return true;
    else return false;
}

（3）入队

bool EnQueue(SeQueue &Q, ElemType x) {
    if((Q.rear+1)%MaxSize==Q.front) return false;
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%MaxSize;
    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;
    return true;
}

3. 队列的链式存储结构

1. 队列的链式存储

队列的链式表示称为链队列，它实际上是一个同时带有队头和队尾指针的单链表。头指针指向队头结点，尾指针指向队尾结点，即单链表的最后一个结点。 队列的链式存储如图所示。

队列的链式存储类型可描述为

typedef struct {
    ElemType data;
    struct LinkNode *next;
} LinkNode;
typedef struct {
    LinkNode *front,*rear;
} LinkQueue;

当Q.front == NULL且Q.rear==NULL时，链式队列为空。
出队时，首先判断是否为空，若不空，则取出队头元素，将其从链表中摘除，并让Q.front指向下一个结点（若该结点为最后一个结点，则置Q.front和Q.rear都为NULL）。入队时，建立一个新结点，将新结点插入到链表的尾部，并改让Q.rear指向这个新插入的结点（若原队列为空对，则灵Q.front也指向该结点）。
通常将链式队列设计成一个带头结点的单链表。

用单链表表示的链式队列特别适合于数据元素变动比较大的情形，而且不存在队列满且产生溢出的问题。另外，加入程序中要使用多个队列，与多个栈的情形一样，最好使用链式队列，这样就不会出现存储分配不合理和“溢出”的问题。

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) {
    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;
    p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)
        Q.rear=Q.front;
    free(p);
    return true;
}

4. 双端队列

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

在双端队列进队时，前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列中的前端进的元素的后面。在双端队列出队时：无论前端还是后端出队，先出的元素排在后出的元素的前面。
输出受限的双端队列：允许在一端进行插入和删除，但在另一端只允许插入的双端队列称为输出受限的双端队列，如图所示。

输入受限的双端队列：允许在一端进行插入和删除，但在另一端只允许删除的双端队列称为输入受限的双端队列，如图所示。而如果限定双端队列从某个端点插入的元素只能从该端点删除，则该双端队列就蜕变为两个栈底相邻的栈了。