队列

队列的基本概念

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。

3 队列的顺序存储结构

1.队列的顺序存储
队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针front和rear分别指示队头元素和队尾元素的位置。设队头指针指向队头元素，队尾指针指向队尾元素的下一个位置。
队列的顺序存储类型可描述为

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(SqQueue *Q) {
    Q->rear = Q->front = 0;
}

2）判队空

int isEmpty(SqQueue *Q) {
    if (Q->rear == Q->front) {
        return 1;
    } else {
        return 0;
    }
}

3）入队

int EnQueue(SqQueue *Q, ElemType x) {
//队满
    if ((Q->rear + 1) % MAXSIZE == Q->front) {
        return 0;
    }
    Q->data[Q->rear] = x;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return 1;
}

4）出队

int DeQueue(SqQueue *Q, ElemType x) {
    if (Q->rear == Q->front) {
        return 0;
    }
    x = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return 1;
}

4 队列的链式存储结构

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）判队空

int IsEmpty(LinkQueue *Q) {
    if (Q->front == Q->rear) {
        return 1;
    } else {
        return 0;
    }
}

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）出队

int DeQueue(LinkQueue *Q, ElemType *x) {
    if (Q->front == Q->rear) {
        return ERROR;
    }
    LinkNode *p = Q->front;
    *x = p->data;
    Q->front->next = p->next;
    if (Q->rear == Q->front) {
        Q->rear = Q->front;
    }
    free(p);
    return OK;
}

5 双端队列

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

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

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

队列