队列文档之链队

链队 定义 概念

采用链式存储的队列称为链队。链队是一个同时带有队头指针和队尾指针的单链表。其中队头指针始终指向队头结点，队尾指针始终指向队尾结点（即单链表的最后一个结点）。

注：链式队列和顺序队列的队尾指针指向不同，在顺序队列中队尾指针指向队尾元素的下一个位置，在链式队列中队尾指针指向队尾结点。

结构体

链队中元素结点结构体定义：

typedef struct QNode {
    
    int data;
    
    struct QNode *next;
} QNode;

链队结构体定义：

typedef struct {
    
    QNode *front;
    
    QNode *rear;
} LinkedQueue;

特点

• 当 queue->rear==NULL 或者 queue->front==NULL 时队空。
• 不存在队满的情况，假设内存无限大的情况下。
• 队头指针 front 始终指向队头结点；队尾指针 rear 始终指向队尾结点。
• 入队操作：创建新结点，将新结点插入到链表的尾部，并让队尾指针 rear 指向这个新结点。如果原队列为空，那么让队头指针 front 也指向该结点。
• 出队操作：首先判断队列是否为空，若不为空，则取出队头指针 front 所指向的结点元素，将其从链表中摘除，并让队头指针 front 指向其后继结点。如果该结点是最后一个结点，则将队头指针 front 和队尾指针 rear 都指向 NULL。
• 不带头结点的链式队列在操作上比较麻烦，因此通常将链式队列设计成一个带头结点的单链表，这样插入和删除操作就统一了。
• 用单链表表示的链式队列特别适合数据元素变动比较大的情况，并且不存在队列满而产生的溢出问题。

基本操作

注，完整代码请参考：

• LinkedQueue.c
• LinkedQueue.java
• LinkedQueueTest.java

概述

链队的常见操作如下：

• void init(LinkedQueue **queue)：初始化链队。其中 queue 表示链队。
• int isEmpty(LinkedQueue *queue)：判断链队是否为空。其中 queue 表示链队。如果链队为空则返回 1，否则返回 0 表示非空。
• int enQueue(LinkedQueue **queue, int ele)：将元素进队。其中 queue 表示链队；ele 表示待插入的新元素值。如果链队为满则不能入队，则返回 0；如果入队成功则返回 1 表示成功。
• int deQueue(LinkedQueue **queue, int *ele)：将元素出队。其中 queue 表示链队。ele 用来存放出队的元素。如果链队为空则不能出队，则返回 0；如果出队成功则返回 1 表示成功。
• int size(LinkedQueue *queue)：获取链队的长度。其中 queue 表示链队。返回链队中元素个数。
• int getFront(LinkedQueue *queue, int *ele)：获取链队队头元素。其中 queue 表示链队；ele 用来存放队头元素。如果链队为空则无法获取队头元素则返回 0，否则返回 1。
• int getRear(LinkedQueue *queue, int *ele)：获取链队队尾元素。其中 queue 表示链队；ele 用来存放队尾元素。如果链队为空则无法获取队尾元素则返回 0，否则返回 1。
• void print(LinkedQueue *queue)：打印链队中所有元素。其中 queue 表示链队。
• void clear(LinkedQueue **queue)：清空链队所有元素。其中 queue 表示链队。
• void destroy(LinkedQueue **queue)：销毁链队。其中 queue 表示链队。

init

初始化链队。

实现步骤：

• 创建链队头结点，将头结点的 front 指针和 rear 指针都指向 NULL，表示是空队列。

实现代码如下：

void init(LinkedQueue **queue) {
    // 其实 queue 就相当于链队列的头结点，不过它有两个指针，分别存储队头结点和队尾结点的地址
    // 为链队列头结点分配存储空间
    *queue = (LinkedQueue *) malloc(sizeof(LinkedQueue));
    // 将队头指针和队尾指针都指向 NULL，表示空队列
    (*queue)->front = NULL;
    (*queue)->rear = NULL;
}

isEmpty

判断链队是否为空，如果为空则返回 1，否则返回 0 表示非空。

实现步骤：

• 判断链队的队头指针 front 或者队尾指针 rear 是否指向 NULL，如果是则表示空队列则返回 1，否则如果不是空队列则返回 0。

实现代码如下：

int isEmpty(LinkedQueue *queue) {
    // 只要链队列的队头指针或者队尾指针指向 NULL 则表示是空队
    if (queue->front == NULL || queue->rear == NULL) {
        return 1;
    } else {
        return 0;
    }
}

enQueue

将元素入队。

实现步骤：

• 创建新结点，为新结点分配空间，指定数据域为 ele，指定指针域初始指向 null，表示这是一个新结点。
• 判断队列是否为空。如果队列为空，则新结点入队，既是队头结点也是队尾结点。即将队头指针 front 和队尾指针 rear 都指向新结点。
• 如果队列非空，则将新结点插入到队尾结点的后面，然后将队尾指针 rear 指向新结点。

实现代码如下：

void enQueue(LinkedQueue **queue, int ele) {
    // 0.因为是链表来表示队列，理论上不存在队满的情况，所以不需要校验队满

    // 1.创建新结点
    // 1.1 为新结点分配空间
    QNode *newNode = (QNode *) malloc(sizeof(QNode));
    // 1.2 为新结点指定数据域
    newNode->data = ele;
    // 1.3 为新结点指定数据域，初始指向 NULL
    newNode->next = NULL;

    // 2.将新结点入队
    // 2.1 若队列为空，则新结点是队头结点，也是队尾结点
    if ((*queue)->rear == NULL) {
        // 因为链队列只有一个结点，所以将队头指针和队尾指针都指向新结点
        (*queue)->front = newNode;
        (*queue)->rear = newNode;
    }
    // 2.2 如果队列非空，则将新结点插入到队尾结点的后面，并将队尾指针指向新结点
    else {
        // 局部变量，记录队尾结点
        QNode *tailNode = (*queue)->rear;
        // 2.2.1 将新结点插入到队尾结点的后面
        tailNode->next = newNode;
        // 2.2.2 将队尾指针指向新结点
        (*queue)->rear = newNode;
    }
}

deQueue

将元素出队，即从链队的头部出队。如果不是空队列才能出队，用 ele 保存出队元素的值，然后返回 1 表示出队成功；如果是空队列，则返回 0 表示出队失败。

实现步骤：

• 参数校验，如果队空则不能出队。返回 0 表示出队失败。
• 用 ele 保存队头结点的元素值。
• 判断如果队列中只有一个元素（当队头指针和队尾指针指向同一个结点时就表示队列中只有一个元素），那么将队头指针 front 和队尾指针 rear 都指向 NULL。因为只有一个元素出队后，队列就会变成空队列。
• 如果队列中不止一个元素，那么将队头指针 front 指向下一个结点。
• 然后释放原队头结点的空间。
• 返回 1 表示出队成功。

实现代码如下：

int deQueue(LinkedQueue **queue, int *ele) {
    // 0.参数校验，如果队空则不能出队
    if ((*queue)->front == NULL || (*queue)->rear == NULL) {
        return 0;
    }

    // 1.将队头结点出队
    // 1.1 变量，记录链队列的队头结点
    QNode *frontNode = (*queue)->front;
    // 1.2 用 ele 保存队头结点的数据域，即要出队的结点值
    *ele = frontNode->data;
    // 1.3 删除队头结点并修改队头指针
    // 1.3.1 如果队列中只有一个结点时的出队操作需要特殊处理，因为需要将队头指针和队尾指针都指向 NULL
    if ((*queue)->front == (*queue)->rear) {
        (*queue)->front = NULL;
        (*queue)->rear = NULL;
    }
    // 1.3.2 当队列不止一个结点时，将队头指针指向原队头结点的后继结点
    else {
        (*queue)->front = frontNode->next;
    }
    // 1.4 释放原队头结点
    free(frontNode);
    // 1.5 返回 1 表示出队成功
    return 1;
}

size

统计链队中的结点个数。

实现步骤：

• 声明局部变量 len，用于记录链队的结点个数。

• 从队头结点（即队头指针所指向的结点）开始扫描整个单链表，每个结点出现一次那么变量 len 便加一。

• 最后返回统计结果。

实现代码如下：

int size(LinkedQueue *queue) {
    // 变量，记录链队列结点个数
    int len = 0;
    // 变量，结点链队列的队头结点，相当于单链表的开始结点
    QNode *node = queue->front;
    // 扫描链队列，即遍历单链表，统计结点个数
    while (node != NULL) {
        len++;
        node = node->next;
    }
    return len;
}

getFront

读取队头元素。如果队列非空，则获取队头结点的元素值，用 ele 保存，然后返回 1 表示获取成功。如果队列为空则返回 0 表示获取失败。

实现步骤：

• 参数校验，如果队列为空则返回 0。
• 用 ele 保存队头指针所指向的结点的值。因为链队中队头指针始终指向队头结点。
• 返回 1 表示获取成功。

实现代码如下：

int getFront(LinkedQueue *queue, int *ele) {
    // 0.参数校验，如果链队列为空，则表示不能获取队头元素
    if (queue->front == NULL || queue->rear == NULL) {
        return 0;
    }
    // 1.用 ele 保存队头结点的数据值，即队头指针所指向的结点
    *ele = queue->front->data;
    return 1;
}

getRear

读取队尾元素。如果队列非空，则获取队尾结点的元素值，用 ele 保存，然后返回 1 表示获取成功。如果队列为空则返回 0 表示获取失败。

实现步骤：

• 参数校验，如果队列为空则返回 0。
• 用 ele 保存队尾指针所指向的结点的值。因为链队中队尾指针始终指向队尾结点。
• 返回 1 表示获取成功。

实现代码如下：

int getRear(LinkedQueue *queue, int *ele) {
    // 0.参数校验，如果链队列为空，则表示不能获取队尾元素
    if (queue->front == NULL || queue->rear == NULL) {
        return 0;
    }
    // 1.用 ele 保存队尾结点的数据值，即队尾指针所指向的结点
    *ele = queue->rear->data;
    return 1;
}

print

打印链队中所有元素。

实现步骤：

• 从队头结点开始，扫描整个队列（即单链表），打印每个结点的数据值。

实现代码如下：

void print(LinkedQueue *queue) {
    printf("[");
    QNode *frontNode = queue->front;
    while (frontNode != NULL) {
        printf("%d", frontNode->data);
        if (frontNode->next != NULL) {
            printf(", ");
        }
        frontNode = frontNode->next;
    }
    printf("]n");
}

clear

清空链队。

实现步骤：

• 从队头结点开始，扫描链队中的所有结点，释放每一个结点的存储空间。
• 最后将链队头结点的队头指针 front 和队尾指针 rear 指向 NULL，表示是空队。

实现代码如下：

void clear(LinkedQueue **queue) {
    // 变量，记录链队列中的节点，初始为链队列的队头结点
    QNode *frontNode = (*queue)->front;
    // 扫描链队列所有结点，释放每个结点的空间
    while (frontNode != (*queue)->rear) {
        // 保存当前节点的后继结点，因为要释放结点，所以需要提前保存
        QNode *temp = frontNode->next;
        // 释放当前节点
        free(frontNode);
        // 继续链队列的下一个结点
        frontNode = temp;
    }
    // 最后链队列头结点的队头指针和队尾指针都指向 NULL 表示空队列
    (*queue)->front = NULL;
    (*queue)->rear = NULL;
}

destroy

销毁链队。

实现步骤：

• 释放链队头结点的存储空间。

实现代码如下：

void destroy(LinkedQueue **queue) {
    // 即释放链队列头结点的空间
    free(*queue);
}

注意事项

无。

练习题

• Example002-用带头结点的循环链表表示队列，并且只设一个指针指向队尾结点，实现对应的入队列和出队列的算法
• Example006-设计队列要求入队时增加队列空间，出队后出队元素所占用空间可重复使用，以保持队列空间只增不减，并且要求入队操作和出队操作的时间复杂度都为O(1)