链队列的基本操作

链队列的基本操作

链队列的链接存储结构定义

队列的链接存储结构称为链队列（linked queue)，通常用单链表表示，其节点结构与单链表的节点结构相同，为了使空队列和非空队列的操作一致，链队列也加上头节点，根据队列的先进先出特性，为了操作上的方便，设置对头指针，指向链队列的头节点，对尾指针指向终点节点
链队列示意图

链队列的存储结构定义

typedef int QDataType;   //定义队列元素数据类型，假设为int型
typedef struct QListNode  //定义链队列的节点结构
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

typedef struct Queue   //定义链队列
{
	QNode* _front;
	QNode* _rear;
}Queue;

链队列的初始化

初始化链队列只需申请头节点，然后让队头指针和队尾指针均指向头节点

void QueueInit(Queue* q)
{
	assert(q);
	q->_front = q->_rear = NULL;
}

入队操作

链队列的插入操作只考虑在链表的尾部进行，由于链队列带有头节点，空链队列和非空链队列的插入操作语句一致

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newQNode = (QNode*)malloc(sizeof(QNode));
	if (!newQNode)
	{
		perror("malloc_error!");
		return;
	}
	newQNode->_data = data;
	newQNode->_next = NULL;
	if (!q->_front)
	{
		q->_front = q->_rear = newQNode;
	}
	else
	{
		q->_rear->_next = newQNode;
		q->_rear = q->_rear->_next;
	}
}

出队操作

链队列的删除操作只考虑在链表的头部进行，注意链队列长度等于 1 的特殊情况

void QueuePop(Queue* q)
{
	assert(q);
	assert(q->_rear);
	QNode* s = q->_front;
	if (!q->_front->_next)
	{
		free(s);
		q->_front = q->_rear = NULL;
	}
	else
	{
		q->_front = s->_next;
		free(s);
	}
}

取队头元素

取链队列的队头元素只需返回第一个元素节点的数据域

QDataType QueueFront(Queue* q)
{
	assert(q);
	if (q->_front)
		return q->_front->_data;
	return 0;
}

取队尾元素

取链队列的队尾元素只需返回尾节点的数据域

QDataType QueueBack(Queue* q)
{
	assert(q);
	if (q->_rear)
		return q->_rear->_data;
	return 0;
}

判空

若链队列不空，则_front指针不为NULL，所以只需判断_front指针是否为NULL即可

int QueueEmpty(Queue* q)
{
	assert(q);
	if (!q->_front)
		return 1;
	return 0;
}

队列中有效元素个数

通过循环遍历计数有效元素个数

int QueueSize(Queue* q)
{
	assert(q);
	int count = 0;
	QNode* s = q->_front;
	while (s)
	{
		count++;
		s = s->_next;
	}
	return count;
}

销毁队列

链队列是动态存储分配，需要释放链队列的所有节点的存储空间

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->_front, * s = NULL;
	while (cur)         //依次释放链队列的节点
	{
		s = cur->_next;
		free(cur);
		cur = s;
	}
}

代码总览

//Queue.h
#include<iostream>
#include<assert.h>

using namespace std;

// 链式结构:表示队列
typedef int QDataType;

typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;

 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);



//Queue.cpp
#include "Queue.h"

// 初始化队列
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = q->_rear = NULL;
}

// 队头入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newQNode = (QNode*)malloc(sizeof(QNode));
	if (!newQNode)
	{
		perror("malloc_error!");
		return;
	}
	newQNode->_data = data;
	newQNode->_next = NULL;
	if (!q->_front)
	{
		q->_front = q->_rear = newQNode;
	}
	else
	{
		q->_rear->_next = newQNode;
		q->_rear = q->_rear->_next;
	}
}

void QueuePop(Queue* q)
{
	assert(q);
	assert(q->_rear);
	QNode* s = q->_front;
	if (!q->_front->_next)
	{
		free(s);
		q->_front = q->_rear = NULL;
	}
	else
	{
		q->_front = s->_next;
		free(s);
	}
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	if (q->_front)
		return q->_front->_data;
	return 0;
}

// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
	assert(q);
	if (q->_rear)
		return q->_rear->_data;
	return 0;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	int count = 0;
	QNode* s = q->_front;
	while (s)
	{
		count++;
		s = s->_next;
	}
	return count;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	if (!q->_front)
		return 1;
	return 0;
}


// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->_front, * s = NULL;
	while (cur)
	{
		s = cur->_next;
		free(cur);
		cur = s;
	}
}




//main.cpp
#include"Queue.h"

int main()
{
	Queue con;
	QueueInit(&con);
	for (int i = 0; i < 10; i++)
	{
		QueuePush(&con, i);
	}
	cout << QueueEmpty(&con) << endl;
	for (int i = 0; i < 10; i++)
	{
		cout << QueueFront(&con) << endl;
		cout << QueueBack(&con) << endl;
		cout << QueueSize(&con) << endl << endl;
		QueuePop(&con);
	}
	cout << QueueEmpty(&con) << endl;
	QueueDestroy(&con);
}

运行结果