《C和指针》学习笔记之队列

队列是一种先进先出(FIFO)的结构。排队就是一种典型的队列。首先轮到的是排在队伍最前面的人，新入队的人总是排在队伍的最后。

---

1、队列接口

最常用到的队列接口是insert、delete和first。Insert将元素插入队列尾部，delete将队列的头部元素删除，first返回队列第一个元素的值，但不将其删除。除此之外，还有判断队列是否为空或是否已满的函数：is_empty和is_full。另外还包括链式和动态分配实现的队列需要使用的create_queue和destroy_queue函数，用于创建队列和销毁队列。

/*
** 队列接口
*/
#include <stdlib.h>

#define QUEUE_TYPE int   /*队列中元素类型*/

/*
** create_queue
** 创建一个队列，参数是队列中可以储存元素的最大数量
** 注意：本函数只适用与动态分配数组的队列
*/
void create_queue(size_t size);

/*
** destroy_queue
** 销毁一个队列。不适用于静态数组队列
*/
void destroy_queue(void);

/*
** insert
** 向队列中添加一个新元素
*/
void insert(QUEUE_TYPE value);

/*
** delete_q
** 从队列中移除一个元素，移除队头的元素
*/
void delete_q(void);

/*
** first_q
** 返回队列中第一个元素
*/
QUEUE_TYPE first_q(void);

/*
** is_empty_q
** 判断队列是否为空
*/
int is_empty_q(void);

/*
** is_full_q
** 判断队列是否已满
*/
int is_full_q(void);

---

2、静态数组实现队列

队列的实现需要两个指针，一个指向队头一个指向队尾。普通的静态数组并不适合实现队列，一个比较好的方式是采用循环数组的方式，即数组的首尾相连。然而使用循环数组有一个问题，就是判断队列是空还是满非常困难。有两种方法解决这个问题：一种是在增加一个新变量用于记录队列中元素的个数，插入元素时加一，删除元素时减一；另一种方法是使队列中始终保持有一个位置不用。这里采用第二种方法。
如图1所示，front表示队头指针，rear表示队尾指针。当front与rear的相对位置（注意是相对位置）如左图所示时表示队列为空，如右图所示时队列为满。

即，当满足下面条件时队列为空：
(rear + 1) % ARRAY_SIZE == front
当满足下列条件时队列为满：
(rear + 2) % ARRAY_SIZE == front
注意：ARRAY_SIZE表示的是数组的长度，而队列元素不能填满数组，始终要留一个空位，所以最多存储队列元素个数为：QUEUE_SIZE = ARRAY_SIZE – 1。
综上所述，由静态数组实现队列的程序为：

/*
** 静态数组实现队列
*/
#include "queue.h"
#include <stdio.h>
#include <assert.h>

#define QUEUE_SIZE 100   /*队列中元素最大数量*/
#define ARRAY_SIZE (QUEUE_SIZE)  /*数组的长度*/

/* 
** 用于存储队列元素的数组和指向队列头和尾的指针
*/
static QUEUE_TYPE queue[ARRAY_SIZE];
static size_t front = 1;
static size_t rear = 0;

/*
** insert
*/
void insert(QUEUE_TYPE value)
{
    assert(!is_full_q());
    rear = (rear + 1) % ARRAY_SIZE;
    queue[rear] = value;
}
/*
** delete_q
*/
void delete_q(void)
{
    assert(!is_empty_q());
    front = (front + 1) % ARRAY_SIZE;
}
/*
** first_q
*/
QUEUE_TYPE first_q(void)
{
    assert(!is_empty_q());
    return queue[front];
}
/*
** is_empty_q
*/
int is_empty_q(void)
{
    return (rear + 1) % ARRAY_SIZE == front;
}
/*
** is_full_q
*/
int is_full_q(void)
{
    return (rear + 2) % ARRAY_SIZE == front;
}

注意：front和rear的初始化值不一定是1和0，只要front比rear大1，表示队列为空就可以了。

---

3、动态数组实现队列

/*
** 队列的动态数组实现
*/
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
/*
** 用于存储队列元素的数组和指向队列头和尾的指针
*/
static QUEUE_TYPE *queue;
static size_t     queue_size;
static size_t     array_size;
static size_t front = 1;
static size_t rear = 0;

/*
** create_queue
*/
void create_queue(size_t size)
{
    assert(queue_size == 0);
    queue_size = size;
    array_size = queue_size + 1;
    queue = (QUEUE_TYPE *)malloc(array_size * sizeof(QUEUE_TYPE));
    assert(queue != NULL);
}

/*
** destroy_stack
*/
void destroy_queue(void)
{
    assert(queue_size > 0);
    queue_size = 0;
    array_size = 0;
    free(queue);
    queue = NULL;
}
/*
** insert
*/
void insert(QUEUE_TYPE value)
{
    assert(!is_full_q());
    rear = (rear + 1) % array_size;
    queue[rear] = value;
}
/*
** delete_q
*/
void delete_q(void)
{
    assert(!is_empty_q());
    front = (front + 1) % array_size;
}
/*
** first_q
*/
QUEUE_TYPE first_q(void)
{
    assert(!is_empty_q());
    return queue[front];
}
/*
** is_empty_q
*/
int is_empty_q(void)
{
    return (rear + 1) % array_size == front;
}
/*
** is_full_q
*/
int is_full_q(void)
{
    return (rear + 2) % array_size == front;
}

函数create_queue(size_t size)的参数是队列中实际能存放的元素个数，不是数组大小。队列使用完后一定要用destroy_queue()释放内存。

---

4、链表实现队列

/*
** 队列的链表实现
*/
#include "queue.h"
/*
** 用单相链表实现队列，这个队列没有长度限制
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

#define FALSE 0

/*
** 定义一个结构存储队列元素
*/
typedef struct QUEUE_NODE{
    QUEUE_TYPE value;
    struct QUEUE_NODE *next;
}QueueNode;
/*
** 指向堆栈中的头节点和最后一个节点的指针
*/
static QueueNode *queue;
static QueueNode *last_queue;

/*
** create_queue
*/
void create_queue(size_t size)      /*创建头节点*/
{
    queue = malloc(sizeof(QueueNode));
    assert(queue != NULL);
    queue->value = 0;
    queue->next = NULL;
    last_queue = queue;
}
/*
** destroy_queue
*/
void destroy_queue(void)    /*销毁整个链表，连同头节点一起销毁*/
{
    while(!is_empty_q())
        delete_q();
    free(queue);
    queue = NULL;
}
/*
** insert
*/
void insert(QUEUE_TYPE value)
{
    QueueNode *new_node;
    new_node = malloc(sizeof(QueueNode));
    assert(new_node != NULL);
    new_node->value = value;
    new_node->next = NULL;
    last_queue->next = new_node;
    last_queue = new_node;
}
/*
** delete_q
*/
void delete_q(void)
{
    QueueNode *first_node;
    assert(!is_empty_q());
    first_node = queue->next;
    queue->next = first_node->next;
    free(first_node);
}
/*
** first_q
*/
QUEUE_TYPE first_q(void)
{
    assert(!is_empty_q());
    return queue->next->value;
}
/*
** is_empty_q
*/
int is_empty_q(void)
{
    return queue->next == NULL;
}
/*
** is_full_q
*/
int is_full_q(void)
{
    return FALSE;
}

在这个版本的实现中，使用了头节点，在函数create_queue中创建头节点，头节点是一个空节点。用两个指针表示这个链表，一个指向头节点，一个指向最后一个节点。Insert函数插入节点总是插在最后面，first_q函数总是返回第一个节点的元素，delete_q函数总是删除第一个节点。

---

参考文献

[1] Kenneth A. Reek. C和指针(第二版)[M]. 人民邮电出版社.