队列（上）之链式队列

一、队列的定义

定义：队列（queue）：队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入操作的一端称为队尾，允许删除操作的一端称为队头。

队列与现实生活中的排队机制很像，排在队头的出队，而想入队则只能从队尾开始。

六、循环队列

线性表有顺序存储和链式存储两种结构，队列作为特殊的线性表，自然也有顺序队列和链式队列两种形式。

但是，队列的顺序存储却有很大的缺陷。如果我们要建立元素个数为n的队列，则需要建立一个数组长度不小于n的数组，数组下标为0的为队头，当最大下标的为队尾。若有元素要入队，则只需将其存储在第n+1个位置即可。

而若想出队，则删除了下标为0的元素后，所有在其后的元素都需要向前移动一格，即保持下标为0的元素为队头。但这样做显然浪费了大量时间。

解决该问题的方法就是不再限制下标为0的元素为队头，每次出队后，队头自动变成当前数组下标最小的元素即可。这样就无需所有元素向前移动。

但是，若如此做，则会造成大量的已出队的元素的存储空间浪费。而且，若此时入队元素已经大于n，则我们需要更大的存储空间才行，但队头位置有大量空间未利用，空间浪费严重。

解决以上问题的方法就是如果后面满了，则我们就从头开始，也就是将队列做成头尾相接的循环。我们把这种头尾相接的顺序存储结构的队列称为循环队列。

这样，我们就需要两个指示其队头（front）和队尾（rear）的下标变量。

typedef int data_t;

typedef struct

{

data_t data[MAXSIZE];

int front;//队头位置

int rear;//队尾位置

}SqQueue;

当front==rear时，此时队头和队尾重合，则该队列为空队列；当(rear+1)%QueueSize==front时，此时队尾的下个位置就是队头，则该队列为满队列。注意rear的位置不是队尾元素的位置，而是队尾元素的下一个位置，即当队列满时，队列中还有一个空闲存储空间，但我们规定该状态下就是满队列。

那么，定义好队列的的队头和队尾位置，我们来考虑怎样计算队列长度。

当rear>front时，表示队尾在队头右边，此时队列长度为rear-front；当rear<front时，表示队尾在队友左边，此时计算队列长度应分成两部分，即rear一部分，QueueSize-front一部分，总体长度为rear-front+QueueSize。

通用计算队列长度的公式是

length=(rear-front+QueueSize)%QueueSize

1、判断队是否为空EmptyQueue

//代码见附录

2、判断队是否为满FullQueue

//代码见附录

3、入队操作EnQueue

//代码见附录

4、出队操作DeQueue

//代码见附录

从循环队列的特性我们可以看出，循环队列虽然操作较为简单，但是由于队列定长，因此会出现数据溢出问题。这时我们需要考虑使用队列的链式存储结构。

七、队列的链式存储结构及实现

队列的链式存储结构本质上是从单链表演化而来的。将单链表改造成链式队列，如果将头结点做为队头，最后一个节点做为队尾，则该队列的出队操作方便，而入队操作较慢；反之，如果将头结点做为队尾，最后一个节点做为队头，则该队列的入队操作方便，而出队操作较慢。

那么，能否将单链表稍加改进，使得该链式队列的入队操作和出队操作一样方便呢？

答案是可以的，只需要改进头结点。将“头结点存储一个next指针”改为“头结点存储两个指针front和rear”，front指针指向队头，rear指针指向队尾。这样我们进行出队/入队操作时，只需要访问这两个指针就能快速地找到队头/队尾。

1、队列的链式存储结构定义

将单链表的头结点稍加改造

typedef int data_t;

typedef struct node_t//定义单链表

{

data_t data;

struct node_t *next;

} linknode_t, *linklist_t;

typedef struct//定义链式队列

{

linklist_t front, rear;

} linkqueue_t;

2、判定链式队列是否为空

由于单链表的属性，链式队列几乎不会出现“队列已满”的情况，因此不考虑判定链式队列是否已满的操作。

判定链式队列是否为空，只需要判定队列的front指针是否为空即可。

//代码见附录

3、队列的链式存储结构——入队操作

入队操作其实就是在链表尾部插入节点。新来的数据节点附在当前rear节点之后，并将rear节点指向该节点即可。

//代码见附录

4、队列的链式存储结构——出队操作

出队操作就是将链表的头结点的后继节点出队，并将其之后的节点设置为头结点的后继节点。若链表除头结点外仅剩一个元素，则需将rear指向头结点。

//代码见附录

对于循环队列和链式队列的比较，二者从时间复杂度上来说都是O(1)，不过链式队列需要花费额外的申请节点的时间，而且链式队列删除节点也需要一些时间。从空间上来说，循环队列有固定长度，就意味着循环队列有其存储上限，因此也就存在元素溢出以及空间浪费等问题，而链式队列则不存在这些问题。

总体来说，若可以大致确定元素个数的情况下，推荐使用循环队列；若无法事先预知元素个数，则应使用链式队列。

链式队列代码

#include <stdio.h>

#include <stdlib.h>

#define OK 1

#define ERROR 0

typedef int data_t;

typedef struct node_t//普通单链表节点

{

data_t data;

struct node_t *next;

} linknode_t, *linklist_t;

typedef struct//链式队列的头结点

{

linklist_t front, rear;

} linkqueue_t;

linkqueue_t *CreateEmptyLinkqueue()//创建空队列

{

linkqueue_t *queue;

queue = (linkqueue_t *)malloc(sizeof(linkqueue_t));

if (NULL == queue)

{

perror("Create Empty LinkQueue Error");

return NULL;

}

queue->rear = queue->front = NULL;

return queue;

}

int ClearLinkqueue(linkqueue_t *queue)//清空队列

{

linknode_t *node_remove;

node_remove = queue->front;

while (NULL != node_remove)

{

queue->front = queue->front->next;

free (node_remove);

node_remove = queue->front;

}

queue->front = NULL;

queue->rear = NULL;

return OK;

}

int DestroyLinkqueue(linkqueue_t *queue)//销毁队列

{

if (queue)

{

ClearLinkqueue(queue);

free(queue);

return OK;

}

else

{

printf("DestroyLinkqueue Error\n");

return ERROR;

}

}

int EmptyLinkqueue(linkqueue_t *queue)//判定队列是否为空

{

if (!queue)

{

printf("EmptyLinkqueue Error\n");

return -1;

}

return queue->front == NULL ? OK : ERROR;

}

int EnQueue(linkqueue_t *queue, data_t x)//入队

{

linknode_t *node_new;

if (!queue)

{

printf("EnQueue Error\n");

return ERROR;

}

node_new = (linknode_t *)malloc(sizeof(linknode_t));

node_new->data = x;

node_new->next = NULL;

if(EmptyLinkqueue(queue)==OK)

{

queue->front = queue->rear = node_new;

}

else

{

queue->rear->next = node_new;

queue->rear = node_new;

}

return OK;

}

int DeQueue(linkqueue_t *queue, data_t *x)//出队

{

linknode_t *node_remove;

if(!queue)

{

printf("DeQueue Error\n");

return ERROR;

}

if(EmptyLinkqueue(queue)==OK)

{

printf("queue is Empty\n");

return ERROR;

}

node_remove = queue->front;

queue->front = node_remove->next;

if (NULL == queue->front)

queue->rear = NULL;

*x = node_remove->data;

free(node_remove);

return OK;

}

int VisitQueue(linkqueue_t *queue)//遍历队列

{

linknode_t *node;

printf("aueue = {");

node = queue->front;

if (NULL == node) {

printf("}\n");

return OK;

}

while (NULL != node) {

printf("%d,", node->data);

node = node->next;

}

printf("\b}\n");

return OK;

}

int main()

{

/*

linkqueue_t *queue = (linkqueue_t*)malloc(sizeof(linkqueue_t));

data_t data;

int i;

EnQueue(queue,20);

EnQueue(queue,30);

DeQueue(queue,&data);

printf("data is %d\n",data);

DeQueue(queue,&data);

printf("data is %d\n",data);

DeQueue(queue,&data);

printf("data is %d\n",data);

for(i=0;i<20;i++)

{

EnQueue(queue,i);

}

VisitQueue(queue);

for(i=0;i<25;i++)//应打印出5个Error

{

DeQueue(queue,&data);

printf("data is %d\n",data);

}

if(DestroyLinkqueue(queue)==OK)

{

printf("DestroyLinkqueue success\n");

}

return 0;

*/

}