数据结构之队列的实现

数据结构之队列的实现

队列是一种先进先出（First-IN First-OUT, FIFO）的结构，实现队列一般有两种方法，第一是使用链表的形式实现，另外一种是使用数组实现。下面分别以这两种方式实现数据结构中的队列。

一、 使用链表实现

队列一般就有下列几个函数：

void init_queue(queue_node *queue); //初始化队列

bool in_queue(queue_node *queue,queue_type value);//进队

bool queue_is_empty(queue_node *queue);//判断队列是否空

bool queue_is_full(queue_node *queue);//判断队列是否已满

queue_type out_queue(queue_node *queue);//出队

代码实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

#define ITEMS_MAX 125  //队列最大的容量
typedef int  queue_type; //队列数值的类型

/*队列节点*/
typedef struct _node
{
queue_type value;
struct _node *next;
}node;

typedef struct _queue_node
{
node *front;
node *rear;
int items;   //记录队列中项目的个数
}queue_node;

int main(void)
{
unsigned char i;
queue_type value;
/*定义一个队列并初始化*/
queue_node q;
init_queue(&q);

/*in_queue*/
for(i=1; i<125; i++)
{
if(queue_is_full(&q))
{
printf("queue is full\n");
exit(-1);
}
else
{
in_queue(&q,i);
}
}

/*out_queue*/
for(i=1; i<125; i++)
{
if(queue_is_empty(&q))
{
printf("queue is empty\n");
exit(-1);
}
else
{
value = out_queue(&q);
printf("%d\n",value);
}

}
}

/*@brief  Initialize a queue
*@param  queue:pointer to a queue_node structrue
*@retval None
*/
void init_queue(queue_node *queue)
{
queue->front = NULL;
queue->rear = NULL;
queue->items = 0;
}

/*@brief  queue up
*@param  queue_node:Pointer to a queue_node structrue
*        queue_type:
*@retval None
*/
bool in_queue(queue_node *queue,queue_type pvalue)
{
node *pnew;
pnew = (node*)malloc(sizeof(node));
if(pnew == NULL)
{
printf("create a new queue node false\n");
return false;
}
pnew->value = pvalue;
pnew->next = NULL;

if(queue_is_empty(queue)) //初次
{
queue->front = pnew;
queue->rear = pnew;
}
else
{
queue->rear->next = pnew; //链接到队尾尾端
queue->rear = pnew;       //记录队尾尾端位置
}

queue->items++;

return true;
}

/*@brief  whether the queue is empty
*@param  queue_node:Pointer to a queue_node structrue
*@retval None
*/
bool queue_is_empty(queue_node *queue)
{
if(queue->items == 0)
{
return true;
}
else
{
return false;
}
}

/*@brief  whether the queue is full
*@param  queue_node:Pointer to a queue_node structrue
*@retval None
*/
bool queue_is_full(queue_node *queue)
{
if(queue->items >= ITEMS_MAX)
{
return true;
}
else
{
return false;
}
}

/*@brief  queue out
*@param  queue_node:Pointer to a queue_node structrue
*@retval None
*/
queue_type out_queue(queue_node *queue)
{
queue_type temp;
node *p;

if(queue_is_empty(queue))
{
printf("The queue is empty\n");
exit(-1);
}

temp = queue->front->value;
p = queue->front;
queue->front = queue->front->next;
free(p);

queue->items--;
if(queue->items == 0)
{
queue->rear = NULL;
}

return temp;
}

二、使用数组实现队列

使用数组实现队列，当有出队时，如果不把后面的数据向前移动，这样就会造成队列的容量越来越小，如果把后面的数据向前移动，就会造成很大开销；



解决这样个问题就是使用循环数组的形式，就是把队列的尾部环绕到数组的头部；这样当已出队删除的位置可以从新存储入队。



使用循环数组实现队列，又会引出另外一个问题，就是无法区别队列满与空，

当队列为满时如下所示：



当队列为满时，把队列中的元素都出列，那么队列就空了，为空时如下所示：



所以循环数组实现队列有无法识别队列满与队列空的现象，解决这一问题可以引入一个变量记录队列的元素，也可以牺牲队列中一个元素位置，来区分满与空，下面代码就是使用牺牲一个元素位置来区分的。

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

//队列容量大小，实质是100-1，一个位置空出用于区分队列满与空
#define QUEUE_DEEP  100
typedef unsigned char queue_type; //队列数值类型

typedef struct _queue_msg
{
queue_type buffer[QUEUE_DEEP];
unsigned char front;
unsigned char rear;
}queue_msg;

/*定义并初始化一个队列*/
queue_msg queue=
{
.front = 1,
.rear = 0,
};

bool queue_is_empty(queue_msg *queue);
bool queue_is_full(queue_msg *queue);
bool in_queue(queue_msg *queue,queue_type value);
queue_type out_queue(queue_msg *queue);

int main(void)
{
unsigned char i;
queue_type value;

/*in_queue*/
for(i=1; i<=99; i++)
{
in_queue(&queue,i);
}
/*out_queue*/
for(i=1; i<=99; i++)
{
value = out_queue(&queue);
printf("%d\n",value);
}
value = out_queue(&queue);
}

bool in_queue(queue_msg *queue,queue_type value)
{
if(queue_is_full(queue))
{
printf("The queue is fulled\n");
exit(-1);
}
else
{
//等价与 queue->rear = (queue->rear+1)%QUEUE_DEEP;
queue->rear++;
if(queue->rear >= QUEUE_DEEP)
{
queue->rear = 0;
}
queue->buffer[queue->rear] = value;
}
return true;
}

queue_type out_queue(queue_msg *queue)
{
queue_type temp;

if(queue_is_empty(queue))
{
printf("The queue is empty\n");
exit(-1);
}
else
{
//等价与 queue->front = (queue->front+1)%QUEUE_DEEP
temp = queue->buffer[queue->front];
queue->front++;
if(queue->front >= QUEUE_DEEP)
{
queue->front = 0;
}
}
return temp;
}
//判断队列是否空
bool queue_is_empty(queue_msg *queue)
{
return ((queue->rear+1)%QUEUE_DEEP == queue->front);
}
//判断队列是否满
bool queue_is_full(queue_msg *queue)
{
return ((queue->rear+2)%QUEUE_DEEP == queue->front);
}