数据结构 - 队列（链式队列、通用数据类型）

已于 2022-07-24 21:20:38 修改
阅读量207 收藏
点赞数
分类专栏： C语言 数据结构 文章标签： 数据结构 算法 c++
于 2022-07-24 19:16:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lamdonn/article/details/125962796
版权

队列的概念

在该文章数据结构 - 队列（顺序队列、单一数据类型）中讲述顺序的队列，本文则浅述一下链式队列。

链式队列的思路

链式队列实现起来会灵活很多，理论上是可以做到无限长的，出队入队也比较容易实现。本文所介绍的还是一种通用数据类型式的链式队列，使用上没有之前单一数据类型的那种复杂（要先定义个队列控制结构体，定义个数组，有控制体来完成数组的控制实现队列），而是可以定义int、float等类型队列，同样自定义的结构体类型的队列也可以。具体的实现思路参考数据结构 - 队列（顺序队列、单一数据类型）。

C语言代码

头文件

#ifndef __queue_H
#define __queue_H

/* 结点结构体定义 */
typedef struct _QUEUE_NODE_
{
	struct _QUEUE_NODE_ *next;
	void *data;
}QUEUE_NODE;

/* 队列结构体定义 */
typedef struct _QUEUE_
{
	QUEUE_NODE *queue_head;
	QUEUE_NODE *queue_tail;
	unsigned int count;
	unsigned char data_size;
	unsigned int queue_size;
}QUEUE;

unsigned char queue_init(QUEUE *queue, unsigned char data_size, unsigned int queue_size);
unsigned char queue_empty(QUEUE *queue);
unsigned char queue_full(QUEUE *queue);
unsigned char queue_push(QUEUE *queue, void *data);
unsigned char queue_pop(QUEUE *queue, void *data);
void queue_clean(QUEUE *queue);
void queue_free(QUEUE *queue);

#endif

在“QUEUE”结构体内部已经定义好原来控制体所需要的成员，也增加“data_size”变量实现数据类型的通用。

源文件

#include "queue.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/*********************************************************************************************************
** 函数名称:	queue_init
** 功能描述:	队列初始化
** 输　入:		queue: 队列
				data_size: 数据域大小
				queue_size: 队列长度大小 0-无限队列；其他-特定大小的循环队列
** 输　出:		1: 成功
				0: 失败
********************************************************************************************************/
unsigned char queue_init(QUEUE *queue, unsigned char data_size, unsigned int queue_size)
{
	unsigned int i = queue_size - 1; // 第一块不在循环内创建
	QUEUE_NODE *temp_node = NULL;
	QUEUE_NODE *last_node = NULL;

	if (queue_size == 0) // 无限队列
	{
		queue->queue_head = NULL;
		queue->queue_tail = NULL;
		queue->data_size = data_size;
		queue->count = 0;
		queue->queue_size = queue_size;
	}
	else // 循环队列
	{
		// 创建第一块空间作为队头
		temp_node = (QUEUE_NODE *)malloc(sizeof(QUEUE_NODE));
		if (temp_node == NULL)
		{
			return 0;
		}
		temp_node->data = malloc(queue->data_size);
		if (temp_node->data == NULL)
		{
			free(temp_node);
			return 0;
		}

		queue->queue_head = temp_node;

		while (i--) // 初始化每一块空间
		{
			// 获取前一个创建的
			last_node = temp_node;

			// 创建空间
			temp_node = (QUEUE_NODE *)malloc(sizeof(QUEUE_NODE));
			temp_node->data = malloc(queue->data_size);
			
			last_node->next = temp_node;
		}

		// 首尾相连，形成循环
		temp_node->next = queue->queue_head;

		queue->queue_tail = NULL;
		queue->data_size = data_size;
		queue->count = 0;
		queue->queue_size = queue_size;
	}

	return 1;
}

/*********************************************************************************************************
** 函数名称:	queue_empty
** 功能描述:	判断队列是否为空
** 输　入:		queue: 队列
** 输　出:		1: 为空
				0: 非空
********************************************************************************************************/
unsigned char queue_empty(QUEUE *queue)
{
	if (queue->count == 0)
	{
		return 1;
	}
	else 
	{
		return 0;
	}
}

/*********************************************************************************************************
** 函数名称:	queue_full
** 功能描述:	判断队列是否满
** 输　入:		queue: 队列
** 输　出:		1: 为满
				0: 非满
********************************************************************************************************/
unsigned char queue_full(QUEUE *queue)
{
	if (queue->queue_size != 0 && queue->count >= queue->queue_size)
	{
		return 1;
	}
	else 
	{
		return 0;
	}
}

/*********************************************************************************************************
** 函数名称:	queue_push
** 功能描述:	入队操作
** 输　入:		queue: 队列
				data: 入队变量的地址
** 输　出:		1: 入队成功  
				0: 入队失败
********************************************************************************************************/
unsigned char queue_push(QUEUE *queue, void *data)
{
	QUEUE_NODE *temp_node = NULL;

	if (queue->queue_size == 0)
	{
		// 创建空间，赋值
		temp_node = (QUEUE_NODE *)malloc(sizeof(QUEUE_NODE));
		temp_node->data = malloc(queue->data_size);
		memcpy(temp_node->data, data, queue->data_size);
		temp_node->next = NULL;

		// 更新队头队尾指针
		if (queue->count == 0)
		{
			queue->queue_head = temp_node;
		}
		else 
		{
			queue->queue_tail->next = temp_node;
		}
		queue->queue_tail = temp_node;

		// 更新计数
		queue->count++;

		return 1;
	}
	else
	{
		// 判断队列是否满了
		if (queue->count >= queue->queue_size)
		{
			return 0;
		}

		// 队尾指向空，表明刚初始化，队列为空
		if(queue->queue_tail == NULL)
		{
			queue->queue_tail = queue->queue_head;
		}
		else 
		{
			queue->queue_tail = queue->queue_tail->next;
		}

		// 赋值
		memcpy(queue->queue_tail->data, data, queue->data_size);

		// 更新计数
		queue->count++;

		return 1;
	}
}

/*********************************************************************************************************
** 函数名称:	queue_pop
** 功能描述:	出队操作
** 输　入:		queue: 队列
				data: 出队变量的地址
** 输　出:		1: 出队成功  
				0: 出队失败
********************************************************************************************************/
unsigned char queue_pop(QUEUE *queue, void *data)
{
	QUEUE_NODE *temp_node = queue->queue_head;

	// 判断队列是否为空
	if (queue->count == 0)
	{
		return 0;
	}

	if (queue->queue_size == 0)
	{
		// 更新队头
		queue->queue_head = queue->queue_head->next;

		// 获取数据
		memcpy(data, temp_node->data, queue->data_size);

		// 释放空间
		free(temp_node->data);
		free(temp_node);

		// 更新计数
		queue->count--;

		return 1;
	}
	else
	{
		// 更新队头
		queue->queue_head = queue->queue_head->next;

		// 获取数据
		memcpy(data, temp_node->data, queue->data_size);

		// 更新计数
		queue->count--;

		// 队列为空，让队尾指向空
		if (queue->count == 0)
		{
			queue->queue_tail = NULL;
		}

		return 1;
	}
}

/*********************************************************************************************************
** 函数名称:	queue_clean
** 功能描述:	队列清空
** 输　入:		queue: 队列
** 输　出:		无
********************************************************************************************************/
void queue_clean(QUEUE *queue)
{
	QUEUE_NODE *temp_node = NULL;

	if (queue->queue_size == 0)
	{
		// 循环删除
		queue->count++;
		while(--queue->count)
		{
			temp_node = queue->queue_head;
			queue->queue_head = queue->queue_head->next;

			free(temp_node->data);
			free(temp_node);
		}
		queue->queue_tail = NULL;
	}
	else 
	{
		queue->queue_tail = NULL;
		queue->count = 0;
	}
}

// 
/*********************************************************************************************************
** 函数名称:	queue_free
** 功能描述:	释放队列
** 输　入:		queue: 队列
** 输　出:		无
********************************************************************************************************/
void queue_free(QUEUE *queue)
{
	unsigned int i = 0;
	QUEUE_NODE *temp_node = NULL;

	i = queue->queue_size==0?queue->count:queue->queue_size;

	// 针对循环队列释放创建的空间
	while(i--)
	{
		temp_node = queue->queue_head;
		queue->queue_head = queue->queue_head->next;

		// 释放空间
		free(temp_node->data);
		free(temp_node);
	}

	queue->queue_head = NULL;
	queue->queue_tail = NULL;
	queue->data_size = 0;
	queue->count = 0;
	queue->queue_size = 0;
}

测试

#include <stdio.h>
#include "queue.h"

typedef struct 
{
	char name[12];
	int heght;
	float weight;
}STUDENT;

void print_student(STUDENT student)
{
	printf("name: %s, height = %d, weight = %.2f\r\n", student.name, student.heght, student.weight);
}

int main()
{
	int i = 0;
	QUEUE queue;
	QUEUE queue_stu;
	int data = 0;
	STUDENT student;
	int queue_len = 0;

	queue_init(&queue, sizeof(int), 10);
	queue_init(&queue_stu, sizeof(STUDENT), 10);

	for (i = 0; i < 11; i++)
	{
		data = i + 1;
		queue_push(&queue, &data);

		sprintf(student.name, "student%d", i);
		student.heght = 170 + i;
		student.weight = 60.5 + i;
		queue_push(&queue_stu, &student);
	}
	
	queue_len = queue.count;
	for (i = 0; i < queue_len; i++)
	{
		if (queue_pop(&queue, &data) == 1)
		{
			printf("pop<%d> = %d\r\n", i, data);
		}
	}

	queue_len = queue_stu.count;
	for (i = 0; i < queue_len; i++)
	{
		if (queue_pop(&queue_stu, &student) == 1)
		{
			print_student(student);
		}
	}

	getchar();
	return 0;
}

结果:
在这里插入图片描述

在初始化函数中，传入的变量“queue_size”还决定了队列的形式，传入0则为无限队列不限制队列长度，其他数则为特定长度的有限队列，并且在初始化时候完成空间分配。
建议： 这种链式的无限队列不建议在中断中使用，中断服务函数讲究快进快出，而链式队列每进一次队都要进行空间分配，会耗费很多的时间。
最后的最后，本人才疏学浅，此代码仅供参考交流，本人如有叙述错误，麻烦各位指正，有什么好的建议欢迎留言。

Lamdonn
关注
专栏目录
数据类型（四）队列
柒年
08-23 1092
队列 队列是一个相同元素的可变尺寸的有序集合。 队列的声明是使用带美元的符号[$]，队列元素的标号是从0到$。 队列：在任何地方可以添加/插入/删除元素，可以通过索引的方式对任何元素进行访问。 队列常用的操作（pdf）： int q[$] = {2, 4, 8}; int p[$]; int e, pos; e = q[0]; // 读取第一个（最左边）条目。 e = q[$]; // 读取最后一个（最右边）条目。 q[0] = e; // 写第一个元素
数据结构（八） -- C语言版 -- 栈和队列 - 队列的设计与实现
青椒*^_^*凤爪爪的博客
03-16 9865
本文中没有涉及到很多的相关理论知识，也没有做深入的了解，所以，您如果是想要系统的学习、想要多学习关于理论的知识等，那么本文可能并不合适您。 本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
数据类型-C-队列
qwe13600as的博客
08-18 408
一、队列是什么 队列是一种可以实现“先进先出”的存储结构,其实,说简单点,队列就是排队,跟我们日常生活中到银行取钱排队，排队打饭在道理上是一样的。 队列通常可以分为两种类型：        ①链式队列（由链表实现）.        ②静态队列（由数组实现）,静态队列通常都必须是循环队列.     循环队列的两个参数：        ①front,front指向队列的第一个元素.
数据类型3.队列
xiaoyu1381的博客
08-06 161
数据结构 队列
数据结构 - 队列（顺序队列、通用数据类型）
lamdonn的博客
07-24 376
数据结构 - 队列（顺序队列、通用数据类型）
队列数据类型及Python实现
shijiuhuaR的博客
10-16 704
队列数据类型及Python实现
C++数据结构之链式队列实现
09-20
为了实现通用性，我们可以使用C++的模板机制来定义链式队列类，使其可以处理不同类型的数据： ```cpp template class LinkQueue { public: // 构造函数 LinkQueue(); // 析构函数 ~LinkQueue(); // 创建空...
数据结构-栈与队列-队列
suxiaorui的博客
07-31 525
队列的定义 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为对头。 队列的抽象数据类型 队列的顺序存储结构 假设一个队列有n个元素，则顺序存储的队列需建立一个大于n的数组，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一...
数据结构-C++实现.zip
最新发布
06-17
C++是一种强大的、通用的编程语言，它支持面向对象编程，使得实现数据结构更加直观和高效。在这个“数据结构-C++实现.zip”压缩包中，很可能是包含了一系列用C++语言实现的数据结构示例代码和相关学习资源。 数据...
算法与数据结构-030113451
08-03
**广义表**是一种可以包含其他表的表，是更通用的数据结构，可以表示复杂的层次关系。 **二叉树**是一种特殊的树形结构，每个节点最多有两个子节点，分为左子节点和右子节点。 **链表的实战讲解**部分，可能包含...
数据结构——队列篇（普通数据类型、类作为元素以及队列类模板的实现）
BODOA
08-08 234
https://blog.csdn.net/feiyanjia/article/details/80988162#commentBox（转发）
【数据结构之队列系列】队列详解
胡坚涛的博客
01-11 3976
前面我们学习了一种数据结构：栈，栈是一种只允许在一端尽进行插入删除的数据结构，而今天我们将学习另一种数据结构：队列，队列是一种支持在一端进行插入，在另一端进行删除的数据结构。
数据结构-队列之链式队列
10-22 2111
队列的链式表示称为链队列，它实际上是一个同时带有队头指针和队尾指针的单链表。头指针指向队头节点，尾指针指向队尾节点，即单链表的最后一个节点。 当q.front==NULL且q.rear==NULL时，链式队列为空。 出队时，首先判断队列是否为空，如果不为空，则取出队头元素，将其从链表中删除，并让q.front指向下一个节点（若该节点为最后一个节点，则置q.front和q.rear都为null）。 ...
常用数据结构-队列 (Queue)
yueerba126的博客
10-28 248
⚠️ 注意: 以上的工具类并不能代替Java SDK中的队列，而是为特定的应用场景提供了额外的功能。在选择时，应当基于实际需求来选择最合适的工具类。Apache Commons Collections 提供了一系列增强的数据结构和算法，对于队列来说，它扩充了 Java SDK 提供的队列功能。Google Guava 是另一个功能丰富的 Java 库，它提供了一些队列的增强功能。
数据结构—队列Queue（数据类型int）
精神小伙
08-03 2813
#include&amp;lt;malloc.h&amp;gt; #include&amp;lt;assert.h&amp;gt; typedef int QueueDataType; typedef struct QueueNode { QueueDataType _data; struct QueueNode* _next; }QueueNode; typedef struct Queue { Q...
背包、栈和队列（集合类数据类型的实现）
上帝已逝，自求多福
04-27 4962
作者：disappearedgod 文章出处：http://blog.csdn.net/disappearedgod/article/details/23349311 时间：2014-4-27
背包、队列、栈（附数据类型实现）
昝昝的博客
07-31 1483
背包、队列和栈背包、队列和栈数据类型都非常基础并且应用广泛。API背包背包是一种不支持从中删除元素的集合数据类型，目的是帮助用例收集元素并迭代所有收集到的元素，也是检查背包是否为空，或者获取背包中元素的数量。队列队列是一种基于先进先出（FIFO）策略的集合类型。在实际应用中使用队列的只要原因是在用集合保存元素的同事保存它们的相对顺序：使他们入列顺序和出列顺序相同。栈下压栈（简称栈）是一种基于先进后出
数组型队列（queue)的使用（支持自定义数据类型）（C++版）
MichaelLiang的博客
05-05 7677
数组型队列（queue)的使用（支持自定义数据类型）C++版 最近用到了数据结构中的queue，标准模板库STL里面的queue是指针型队列，不支持访问队列中的任意元素。故网上找了很多代码，其中 http://blog.csdn.net/juckciy/article/details/23787277 基本实现了我想要的功能，但使用起来比较麻烦。我便在该文代码的基础上，调试了bug，并将代码封装为templat。
数据结构：链式栈的操作实现与栈的应用解析
在数据结构中，栈和队列是两种重要的线性数据结构。 栈是一种后进先出（LIFO）的数据结构，仅允许在栈顶进行插入（进栈）和删除（退栈）操作。栈分为栈顶（top）和栈底（bottom），新的元素总是被压入栈顶，而删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值