C语言实现优先队列 | 图解原理与代码实现

最新推荐文章于 2024-04-14 18:43:41 发布
最新推荐文章于 2024-04-14 18:43:41 发布
阅读量1.4k 收藏 24
点赞数
文章标签： c语言 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Proprieter_sz/article/details/128754493
版权
优先队列（Priority Queue）是一种特殊的队列，队列中的元素以优先级进行排序，优先级高的先出列。

二叉堆

本文使用二叉堆（Binary Heap）实现优先队列。

实现

获取队首

插入

删除

二叉堆

O(1)

O(log N)

O(log N)

二叉堆是一颗完全二叉树（存储结构与二叉树相同，但树中元素只存储在索引低的位置）。二叉堆又可分为大堆（max-heap）和小堆（min-heap），大堆中父节点（parent node）数值均大于子节点（child node）数值，小堆则相反，这样可以保证树中最大的元素（或最小）的元素存储在堆顶（根节点）。

二叉堆能保证树中最大的元素处在堆顶，这与优先队列要求优先级最高的元素排在队首相似，因此可以使用二叉堆来实现优先队列。

初始化

二叉堆中的元素可以存储在数组中，初始化时指定二叉堆的容量（最多能存储的元素个数），同时传入一个函数，用于决定是大堆还是小堆。

以下是初始化代码实现：

//------------------------------------------------------------------------------
// Includes

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

//------------------------------------------------------------------------------
// Definitions

typedef int element_t; // 元素类型
typedef struct
{
	bool (*comp)(element_t par, element_t chi); // 比较函数
	element_t *eles;							// 元素存储地址
	int capcity;								// 容量
	int size;									// 存储元素个数
} Priority_Queue_t;

//------------------------------------------------------------------------------
// Functions

/**
 * @brief   
 *          初始化优先队列
 *          
 * @param   capcity 队列容量大小
 * @param   comp    比较函数(用于确保高优先级的元素排在队首)
 *          
 * @date    2023-01-21 created by 吉平.「集」
 *          
 * @return  指向优先队列结构体的指针（返回NULL表示创建失败）
 */
Priority_Queue_t *Priority_Queue_Init(int capcity, bool (*comp)(element_t par, element_t chi))
{
	Priority_Queue_t *pq = NULL;
	pq = (Priority_Queue_t *)calloc(1, sizeof(Priority_Queue_t)); // 申请和0初始化内存空间
	if (pq != NULL)
	{
		// 申请内存空间用于存储元素
		pq->eles = (element_t *)calloc(capcity, sizeof(element_t));
		if (pq->eles != NULL)
		{
			pq->capcity = capcity;
			pq->comp = comp;
		}
		else
		{
			// 申请失败，释放之前申请的内存
			free(pq);
			pq = NULL;
		}
	}

	return pq;
}

插入操作

在往二叉堆插入新的元素时，需要保证不破坏堆的特性。以大堆为例，通过以下步骤来插入新的元素：

  • 第一步：插入一个新的元素到二叉堆末尾，保证二叉堆仍是一颗完全二叉树。

  • 第二步：比较新元素所在节点与其父节点值的大小，（对于大堆）子节点的值大于父节点时，交换它们的值。

  • 第三步：重复第二步骤，直至所有节点满足“父节点数值均大于子节点”。

以下是代码实现：

void swap(element_t *a, element_t *b)
{
	element_t temp = *a;
	*a = *b;
	*b = temp;
}

/**
 * @brief   
 *          插入新元素至优先队列
 *          
 * @param   pq  指向优先队列结构体的指针
 * @param   val 插入队列的新元素
 *          
 * @date    2023-01-22 created by 吉平.「集」
 *          
 * @return  true  新元素插入成功
 * @return  false 新元素插入失败
 */
bool Priority_Queue_Push(Priority_Queue_t *pq, element_t val)
{
	bool rev = false; // 返回值
	int new_node = 0; // 新元素所在节点位置
	int par_node = 0; // 新元素父节点所在位置

	// 检查是否有剩余容量
	if (pq != NULL && pq->size < pq->capcity)
	{
		new_node = pq->size;
		par_node = (new_node - 1) / 2; // 计算父节点所在位置，整除为向下取整
		pq->eles[new_node] = val;
		// 父节点存在，且父节点与子节点的值不满足要求时，交换它们的值
		while (new_node != 0 && pq->comp(pq->eles[par_node], pq->eles[new_node]) == false)
		{
			swap(&pq->eles[par_node], &pq->eles[new_node]);
			// 计算新一轮的节点位置
			new_node = par_node;
			par_node = (new_node - 1) / 2;
		}
		pq->size++;
		rev = true;
	}

	return rev;
}

测试一下这段代码：

#include <stdio.h>

/**
 * @brief   
 *          获取队首元素
 *          
 * @param   pq 指向优先队列结构体的指针
 *          
 * @date    2023-01-23 created by 吉平.「集」
 *          
 * @return  队首元素，队列中无元素时返回0
 */
element_t Priority_Queue_Top(Priority_Queue_t *pq)
{
	element_t rev = 0;
	if (pq != NULL && pq ->size > 0)
	{
		rev = pq->eles[0];
	}
	return rev;
}

bool comparison(element_t par, element_t chi)
{
	// 父节点的值大于子节点
	return (par > chi) ? true : false;
}

int main(void)
{
	Priority_Queue_t *pq = NULL;
	element_t arr[] = {2, 1, 5, 8, 6, 9};

	pq = Priority_Queue_Init(7, comparison);

	for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++)
	{
		Priority_Queue_Push(pq, arr[i]);
		printf("push: %d, top: %d\n", arr[i], Priority_Queue_Top(pq));
	}

	return 0;
}

输出：

push: 2, top: 2
push: 1, top: 2
push: 5, top: 5
push: 8, top: 8
push: 6, top: 8
push: 9, top: 9

删除操作

仍然以大堆为例，通过以下操作来删除根节点元素：

  • 第一步：交换末尾节点与根节点的数值，删除末尾节点。

  • 第二步：比较末尾节点（父节点）与左右子节点的数值，父节点数值较小时，交换父节点与子节点的数值，同时保证交换后的父节点数值大于（或等于）两个子节点的数值。

  • 第三步：重复第二步骤，直至所有节点满足“父节点数值均大于子节点”。

代码实现：

/**
 * @brief   
 *          优先队列删除队首元素
 *          
 * @param   pq 指向优先队列结构体的指针
 *          
 * @date    2023-01-23 created by 吉平.「集」
 *          
 * @return  true  队首元素删除成功
 * @return  false 队首元素删除失败
 */
bool Priority_Queue_Pop(Priority_Queue_t *pq)
{
	bool rev = false;
	bool l_cond = false;
	bool r_cond = false;
	int pos = 0;
	int l_pos = 0;
	int r_pos = 0;

	// 判断是否有元素能够删除
	if (pq != NULL && pq->size > 0)
	{
		swap(&pq->eles[pos], &pq->eles[pq->size - 1]);
		pq->size--; // 删除元素

		while (pos < pq->size - 1)
		{
			l_pos = pos * 2 + 1;
			r_pos = pos * 2 + 2;

			// 子节点存在时判断数值是否满足要求
			l_cond = (l_pos < pq->size) ? pq->comp(pq->eles[pos], pq->eles[l_pos]) : true;
			r_cond = (r_pos < pq->size) ? pq->comp(pq->eles[pos], pq->eles[r_pos]) : true;

			if (l_cond == true && r_cond == true)
			{
				break; // 两个子节点均满足条件，退出循环
			}
			else if (l_cond == false && r_cond == true)
			{
				swap(&pq->eles[pos], &pq->eles[l_pos]); // 只有左子节点不满足条件，与其交换数值
				pos = l_pos;
			}
			else if (l_cond == true && r_cond == false)
			{
				swap(&pq->eles[pos], &pq->eles[r_pos]); // 只有右子节点不满足条件，与其交换数值
				pos = r_pos;
			}
			else
			{
				// 两个子节点均不满足条件，挑选一个交换后数值仍满足要求的节点进行交换
				if (pq->comp(pq->eles[l_pos], pq->eles[r_pos]) == true)
				{
					swap(&pq->eles[pos], &pq->eles[l_pos]);
					pos = l_pos;
				}
				else
				{
					swap(&pq->eles[pos], &pq->eles[r_pos]);
					pos = r_pos;
				}
			}
		}

		rev = true;
	}

	return rev;
}

在主函数中添加一段测试代码：

	for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++)
	{
		printf("top: %d\n", Priority_Queue_Top(pq));
		Priority_Queue_Pop(pq);
	}

输出：

top: 9
top: 8
top: 6
top: 5
top: 2
top: 1

输出符合预期。

完整代码

"Priority_Queue.h"

#ifndef _PRIORITY_QUEUE_H_
#define _PRIORITY_QUEUE_H_

//------------------------------------------------------------------------------
// Includes
#include <stdbool.h>
//------------------------------------------------------------------------------
// Definitions

typedef int element_t; // 元素类型

typedef struct
{
	bool (*comp)(element_t par, element_t chi); // 比较函数
	element_t *eles;							// 元素存储地址
	int capcity;								// 容量
	int size;									// 存储元素个数
} Priority_Queue_t;

//------------------------------------------------------------------------------
// Function declarations

element_t Priority_Queue_Top(Priority_Queue_t *pq);
bool Priority_Queue_Push(Priority_Queue_t *pq, element_t val);
bool Priority_Queue_Pop(Priority_Queue_t *pq);
Priority_Queue_t *Priority_Queue_Init(int capcity, bool (*comp)(element_t par, element_t chi));

#endif

//------------------------------------------------------------------------------
// End of file

"Priority_Queue.c"

//------------------------------------------------------------------------------
// Includes
#include <stdlib.h>
#include <string.h>
#include "Priority_Queue.h"

//------------------------------------------------------------------------------
// Functions

static void swap(element_t *a, element_t *b)
{
	element_t temp = *a;
	*a = *b;
	*b = temp;
}

/**
 * @brief   
 *          获取队首元素
 *          
 * @param   pq 指向优先队列结构体的指针
 *          
 * @date    2023-01-23 created by 吉平.「集」
 *          
 * @return  队首元素，队列中无元素时返回0
 */
element_t Priority_Queue_Top(Priority_Queue_t *pq)
{
	element_t rev = 0;
	if (pq != NULL && pq ->size > 0)
	{
		rev = pq->eles[0];
	}
	return rev;
}

/**
 * @brief   
 *          插入新元素至优先队列
 *          
 * @param   pq  指向优先队列结构体的指针
 * @param   val 插入队列的新元素
 *          
 * @date    2023-01-22 created by 吉平.「集」
 *          
 * @return  true  新元素插入成功
 * @return  false 新元素插入失败
 */
bool Priority_Queue_Push(Priority_Queue_t *pq, element_t val)
{
	bool rev = false; // 返回值
	int new_node = 0; // 新元素所在节点位置
	int par_node = 0; // 新元素父节点所在位置

	// 检查是否有剩余容量
	if (pq != NULL && pq->size < pq->capcity)
	{
		new_node = pq->size;
		par_node = (new_node - 1) / 2; // 计算父节点所在位置，整除为向下取整
		pq->eles[new_node] = val;
		// 父节点存在，且父节点与子节点的值不满足要求时，交换它们的值
		while (new_node != 0 && pq->comp(pq->eles[par_node], pq->eles[new_node]) == false)
		{
			swap(&pq->eles[par_node], &pq->eles[new_node]);
			// 计算新一轮的节点位置
			new_node = par_node;
			par_node = (new_node - 1) / 2;
		}
		pq->size++;
		rev = true;
	}

	return rev;
}

/**
 * @brief   
 *          优先队列删除队首元素
 *          
 * @param   pq 指向优先队列结构体的指针
 *          
 * @date    2023-01-23 created by 吉平.「集」
 *          
 * @return  true  队首元素删除成功
 * @return  false 队首元素删除失败
 */
bool Priority_Queue_Pop(Priority_Queue_t *pq)
{
	bool rev = false;
	bool l_cond = false;
	bool r_cond = false;
	int pos = 0;
	int l_pos = 0;
	int r_pos = 0;

	// 判断是否有元素能够删除
	if (pq != NULL && pq->size > 0)
	{
		swap(&pq->eles[pos], &pq->eles[pq->size - 1]);
		pq->size--; // 删除元素

		while (pos < pq->size - 1)
		{
			l_pos = pos * 2 + 1;
			r_pos = pos * 2 + 2;

			// 子节点存在时判断数值是否满足要求
			l_cond = (l_pos < pq->size) ? pq->comp(pq->eles[pos], pq->eles[l_pos]) : true;
			r_cond = (r_pos < pq->size) ? pq->comp(pq->eles[pos], pq->eles[r_pos]) : true;

			if (l_cond == true && r_cond == true)
			{
				break; // 两个子节点均满足条件，退出循环
			}
			else if (l_cond == false && r_cond == true)
			{
				swap(&pq->eles[pos], &pq->eles[l_pos]); // 只有左子节点不满足条件，与其交换数值
				pos = l_pos;
			}
			else if (l_cond == true && r_cond == false)
			{
				swap(&pq->eles[pos], &pq->eles[r_pos]); // 只有右子节点不满足条件，与其交换数值
				pos = r_pos;
			}
			else
			{
				// 两个子节点均不满足条件，挑选一个交换后数值仍满足要求的节点进行交换
				if (pq->comp(pq->eles[l_pos], pq->eles[r_pos]) == true)
				{
					swap(&pq->eles[pos], &pq->eles[l_pos]);
					pos = l_pos;
				}
				else
				{
					swap(&pq->eles[pos], &pq->eles[r_pos]);
					pos = r_pos;
				}
			}
		}

		rev = true;
	}

	return rev;
}

/**
 * @brief   
 *          初始化优先队列
 *          
 * @param   capcity 队列容量大小
 * @param   comp    比较函数(用于确保高优先级的元素排在队首)
 *          
 * @date    2023-01-21 created by 吉平.「集」
 *          
 * @return  指向优先队列结构体的指针（返回NULL表示创建失败）
 */
Priority_Queue_t *Priority_Queue_Init(int capcity, bool (*comp)(element_t par, element_t chi))
{
	Priority_Queue_t *pq = NULL;
	pq = (Priority_Queue_t *)calloc(1, sizeof(Priority_Queue_t)); // 申请和0初始化内存空间
	if (pq != NULL)
	{
		// 申请内存空间用于存储元素
		pq->eles = (element_t *)calloc(capcity, sizeof(element_t));
		if (pq->eles != NULL)
		{
			pq->capcity = capcity;
			pq->comp = comp;
		}
		else
		{
			// 申请失败，释放之前申请的内存
			free(pq);
			pq = NULL;
		}
	}

	return pq;
}

//------------------------------------------------------------------------------
// End of file

参考链接

本文作者：吉平. 「集」，如有侵权请联系。

吉平. 「集」
关注
  • 0
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言的优先队列
道亦无名
05-20 223
此外，还可以使用其他数据结构（如二叉堆、斐波那契堆等）来实现优先队列，具体选择取决于你的应用场景和性能需求。优先队列是一种数据结构，其中每个元素都有一个优先级，优先级最高的元素最先出队。以下是一个使用数组实现的简单优先队列的示例，其中使用最小堆（min-heap）的性质来保持队列的优先级顺序。这个示例假设元素是可以比较大小的整数，且优先级与元素的值成反比（即值越小，优先级越高）。函数用于从队列中提取并返回优先级最高的元素（即值最小的元素），并重新调整堆以保持其性质。
数据结构（C语言描述）优先队列
qq_740785701的博客
03-30 3202
1 优先队列的定义 优先队列是一个以集合为基础的抽象数据类型。 优先队列中的每一个元素都有一个优先级。 定义在优先队列上的基本运算如下。 Min(H): 返回优先队列H中具有最下优先级的元素。 Insert(x,H): 将元素x插入优先队列H。 DeleteMin(H): 删除并返回优先队列H中具有最小优先级的元素。 在优先队列中，是按照每个对象的优先级顺序进行的。 2 优先队列的简单实现 所有实现字典的方法都可用于实现优先队列。优先队列中元素的优先级可以看成字典中元素的线性序值。 用有序链表实现优先队列，
数据结构之优先级队列 - 超详细的教程，手把手教你认识并运用优先级队列
ミカミミミ博客
04-14 3302
数据结构之优先级队列 - 超详细的教程，手把手教你认识并运用优先级队列。
【C++入门到精通】C++入门 —— priority_queue(STL)优先队列
Yawesh的博客
08-22 9514
本文介绍了priority_queue的概念、特点和使用方法。priority_queue是C++标准库中的一个容器适配器，实现了优先队列的数据结构。优先队列中的元素按照优先级进行排列，可以高效地访问和删除具有最高优先级的元素。我们讨论了priority_queue的基本操作，如插入、删除、访问和判断队列是否为空，以及底层结构的实现原理。此外，还介绍了在priority_queue中使用的仿函数，它决定了元素之间的排序规则。通过了解priority_queue的相关知识，读者可以更好地应用它来解决实际编程中
《Algorithms 4th Edition》读书笔记——2.4 优先队列(priority queue)-Ⅲ
banxuanliu0005的博客
06-15 307
2.4.3 堆的定义 数据结构二叉堆能够很好地实现优先队列的基本操作。在二叉堆的数组中，每个元素都要保证大于等于另两个特定位置的元素。相应地，这些位置的元素又至少要大于等于数组中的两个元素，以此类推。如果我们将所有元素画成一棵二叉树，将每个较大元素和两个较小的元素用边连接就可以很容易看出这种结构。 定义。当一棵二叉树的每个节点都大于等于它的两个子节点，他被称为堆有序。...
优先队列实现
虹少侠的博客
10-31 5729
简单说明 优先队列可以根据key值的大小将元素进行排序、先被pop的通常是优先级最高的。 优先队列的内部实现其实是利用了堆的数据结构、binary heap是一种完全二叉树、以大堆为例、每棵树的根节点的key值一定大于其子孙节点的key值、完全二叉树处了最底层的叶子节点外、其他位置都是填满的。这样我们可以利用数组来存储所有节点。 若将数组从下标1开始存储元素、那么下标为 i 的节点的左孩子节...
数据结构（C语言版）(第2版) —— 严蔚敏 李冬梅 吴伟民.zip
最新发布
06-14
C语言的灵活性使得实现各种数据结构如数组、链表、栈、队列、树、图等变得可能。 1. **数组**：是最基本的数据结构，用于存储同类型元素的集合。C语言中的数组操作直接对应于内存地址的操作，理解数组的动态分配和...
数据结构（c语言版）.zip
06-20
每一章的PPT都应该是对相应主题的详细阐述，包含概念解释、示例、图解和C语言代码示例。通过学习这个配套教学资源包，学生不仅可以理解数据结构的概念，还能掌握如何用C语言进行实际编程，提升解决问题的能力。同时...
数据结构整套课件和清华大学严蔚敏数据结构题集与答案（Ｃ语言版）的答案
10-16
例如，理解何时使用栈来实现递归，何时利用队列处理大量并发请求，或是如何利用二叉树实现快速检索。 总的来说，这份资源为学习者提供了一个全面、系统的学习数据结构的平台，结合理论与实践，有助于提升编程能力和...
数据结构（C语言版第2版）-教材配套资源（学生）.zip
03-03
类似于前面的源代码文件，这部分可能提供了更多的C语言实现案例，特别是针对数据结构先修知识的练习，帮助学生将理论知识与实际编程结合。 7. **算法演示动画.zip**： 这个文件夹包含了一些算法的动态演示，可能...
C语言优先队列
03-31
C语言优先队列 源码实现 仅供参考 用堆实现
数据结构c语言版严蔚敏及庄波数据结构辅助教材.zip
07-22
通过深入学习这个压缩包中的内容，你不仅可以掌握数据结构的基本原理，还能学会如何在C语言环境中实现它们。这将为你的计算机科学学习之路打下坚实的基础，无论你是准备面试、提升编程能力，还是进行软件开发，都将...
数据结构与算法（浙江大学陈越、何**）（pdf格式ppt）
06-13
C语言作为程序设计的基础，通常被用于实现这些数据结构和算法，因为它的效率高且可以直接操作内存，使得理解和实现数据结构更为直观。 浙江大学的MOOC课程通过PPT的形式，结合实例和图解，详细讲解了这些关键概念，...
数据结构（C语言版）（第2版）_PPT课件.zip
03-10
《数据结构（C语言版）（第2版）》的PPT课件可能涵盖以上所有内容，并通过实例和图解帮助学生理解和掌握这些概念。在学习过程中，通过编写和调试代码，可以加深对数据结构实际应用的理解，提高解决问题的能力。此外...
Linux环境编程图文指南.rar
06-12
《Linux环境编程图文指南》是一本专为初学者设计的Linux系统编程教程，它通过丰富的图解和实例代码，帮助读者深入理解Linux操作系统的核心概念和编程技术。这本书涵盖了C语言在Linux环境下的应用，是学习Linux系统...
实现优先级队列
lxylxylxy的博客
01-14 226
优先级队列的实现——堆的调整
优先队列PriorityQueue C语言实现
Sungree的博客
09-15 4027
C语言实现优先队列PriorityQueue基础知识构建优先队列创建判空判满插入查找最值删除摧毁测试输出欢迎讨论 基础知识 堆 堆是用数组实现的二叉树，它的逻辑结构是二叉树，存储结构是数组，所以它没有左右孩子指针。 堆(优先队列)的结构体定义为： #define Type int typedef struct HeapStruct{ int capacity; int size; T...
【C++】优先级队列（priority_queue）的用法与实现
2302_76142697的博客
04-09 1201
主要讲解优先级队列(priority_queue)的使用方法，以及仿函数的应用与示例，最后模拟实现优先级队列的功能。
使用c语言实现 优先队列解决 01背包问题
06-08
好的，我可以为您解答这个问题。 首先，让我们简单介绍一下什么是优先队列和01背包问题。 优先队列是一种数据结构，它可以维护一组元素，并...以上就是使用C语言实现的优先队列解决01背包问题的代码。希望能帮到您！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值