9. 栈和队列（3）

1. 队列的定义

  队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。与栈相反，队列是一种先进先出（First In First Out, FIFO）的线性表。与栈相同的是，队列也是一种重要的线性结构，实现一个队列同样需要顺序表或链表作为基础。

我们的输入缓冲区接受键盘的输入就是按队列的形式输入和输出的，不然的话就很容闹出问题。例如有一天你突然心血来潮，用企鹅发了一句“You are my god”给你女朋友，表示她就是你的全部，但是输入缓冲区在输入god这个单词的时候不用队列这个结构而用栈的结构，就变成了“You are my dog”发出去了。。。。。。

2. 队列的链式存储结构

  队列既可以用链表实现，也可以用顺序表实现。跟栈相反的是，栈一般我们用顺序表来实现，而队列我们常用链表来实现，简称为链队列。

typedef struct QNode {
    ElemType data;         //定义了数据和两个指针 
    struct QNode *next;
} QNode, *QueuePrt;

typedef struct {
    QueuePrt front, rear; // 队头、尾指针
} LinkQueue;

  将队头指针指向链队列的头结点，而队尾指针指向终端结点。（注：头结点不是必要的，但为了方便操作，我们加上了。）如下图所示

  空队列时，front和rear都指向头结点。

3. 创建一个队列

  创建一个队列要完成两个任务：一是在内存中创建一个头结点，二是将队列的头指针和尾指针都指向这个生成的头结点，因为此时是空队列。

typedef struct QNode {
    ElemType data;         //定义了数据和两个指针 
    struct QNode *next;
} QNode, *QueuePrt;

typedef struct {
    QueuePrt front, rear; // 队头、尾指针
} LinkQueue;

3.1 入队列操作

  入队列的操作过程如下：

首先创建一个结点，让这个结点的地址为 p ；其次 e 1 的指针从指向 NULL(^)，转为指向 e2 ；最后将rear(尾指针)指向 e2，然后删除 p 指针。

  具体的代码为

InsertQueue(LinkQueue *q, ElemType e)
{
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(QNode));
    if( p == NULL )
        exit(0);
    p->data = e;
    p->next = NULL;
    q->rear->next = p;
    q->rear = p;
}

上述的代码中，q->rear指的是尾结点，q->rear->next = p;就是将 e1 的指针指向 p；q->rear = p;是将指针直接向后移，移动到最后一位。

3.2 出队列操作

  出队列操作是将队列中的第一个元素移出，队头指针不发生改变，改变头结点的next指针即可。出队列的操作过程如下：

  如果原队列只有一个元素，那么我们就应该处理一下队尾指针。

  具体的代码为

DeleteQueue(LinkQueue *q, ELemType *e)
{
    QueuePtr p;
    if( q->front == q->rear )     //判断本身队列是否为空，为空则直接返回，没有元素可以出列
        return;
    p = q->front->next;
    *e = p->data;
    q->front->next = p->next;
    if( q->rear == p )
        q->rear = q->front;       //判断队列是否只有一个元素，如果只有一个元素那么取出元素后头尾指针重合
    free(p);
}

3.3 销毁队列操作

  由于链队列建立在内存的动态区，因此当一个队列不再有用时应当把它及时销毁掉，以免过多地占用内存空间。

DestroyQueue(LinkQueue *q)
{
    while( q->front ) {
        q->rear = q->front->next;
        free( q->front );
        q->front = q->rear;
    }
}

在上述的过程中，元素一直从顶部取出元素。

4. 队列的存储结构

  为什么小甲鱼上节课说队列的实现上我们更愿意用链式存储结构来存储？我们先按照应有的思路来考虑下如何构造队列的顺序存储结构，然后发掘都遇到了什么麻烦。我们假设一个队列有n个元素，则顺序存储的队列需建立一个大于n的存储单元，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一端则是队头，如下图所示

入队列操作其实就是在队尾追加一个元素，不需要任何移动，时间复杂度为O(1)。出队列则不同，因为我们已经架设下标为0的位置是队列的队头，因此每次出队列操作所有元素都要向前移动。

  在现实中也是如此，一群人在排队买火车票，前边的人买好了离开，后面的人就要全部向前一步补上空位。可是我们研究数据结构和算法的一个根本目的就是要想方设法提高我们的程序的效率，按刚才的方式，出队列的时间复杂度是O(n)，效率大打折扣！如果我们不去限制队头一定要在下标为0的位置，那么出队列的操作就不需要移动全体元素。

但是这样也会出现一些问题，例如按下边的情形继续入队列，就会出现数组越界的错误。

  我们再想想，要解决假溢出的办法就是如果后面满了，就再从头开始，也就是头尾相接的循环。循环队列它的容量是固定的，并且它的队头和队尾指针都可以随着元素入出队列而发生改变，这样循环队列逻辑上就好像是一个环形存储空间。但要注意的是，在实际的内存当中，不可能有真正的环形存储区，我们只是用顺序表模拟出来的逻辑上的循环。

  于是我们发觉了，似乎循环队列的实现只需要灵活改变front和rear指针即可。也就是让front或rear指针不断加1，即时超出了地址范围，也会自动从头开始。我们可以采取取模运算处理：

(rear+1) % QueueSize
(front+1) % QueueSize

首先定义一个循环队列

#define MAXSIZE 100
typedef struct
{
    ElemType *base; // 用于存放内存分配基地址
                            // 这里你也可以用数组存放
    int front;
    int rear;
}

初始化一个循环队列

initQueue(cycleQueue *q)
{
    q->base = (ElemType *) malloc (MAXSIZE * sizeof(ElemType));
    if( !q->base )
        exit(0);
    q->front = q->rear = 0;
}

入队列操作

InsertQueue(cycleQueue *q, ElemType e)
{
    if( (q->rear+1)%MAXSIZE == q->front )
        return; // 队列已满
    q->base[q->rear] = e;
    q->rear = (q->rear+1) % MAXSIZE;
}

出队列操作

DeleteQueue(cycleQueue *q, ElemType *e)
{
    if( q->front == q->rear )
        return ;            // 队列为空
    *e = q->base[q->front];
    q->front = (q->front+1) % MAXSIZE;
}