初阶数据结构之---堆的应用（堆排序和topk问题）

news2024/10/5 14:41:39

引言

上篇博客讲到了堆是什么，以及堆的基本创建和实现，这次我们再来对堆这个数据结构更进一步的深入，将讲到的内容包括：向下调整建堆，建堆的复杂度计算，堆排序和topk问题。话不多说，开启我们今天的内容吧。

堆排序

在讲堆排序之前，我想讲讲建堆的问题。在上篇博客中，我们建堆的时候是存在一个数组（数组中存储着我们建堆所需要的元素），通过一个个取出数组中的元素并插入新的堆中达到建堆目的。这时我们可以想，如果需要直接在存储元素的数组上建堆，应该怎么处理呢？

向上调整建堆

如果你学会了向上调整，你应该不难想到可以这样写：

//这里是在原数组的基础上建立大堆
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void AdjustUp(int* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0) {
		if (a[parent] < a[child]) {
			Swap(&a[parent], &a[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else break;
	}
}

int main()
{
	int arr[] = { 6,5,4,3,2,1,8,7,5,4,2 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		AdjustUp(arr, i);
	}
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

上面的代码即对堆中每一个元素经行向上调整，最后我们就能成功的得到一个大堆

向下调整建堆

其实有一种比向上调整建堆时间复杂度更优的方式，那就是向下调整建堆，这里要注意的一点就是，向下调整的使用条件：根节点的左右子树都得是堆。数组中的元素开始是无序的，想要向下调整建堆，就需要从下往上建。由于二叉树最后一层不需要向下调整，所以我们可以直接从倒数第二层开始向下调。倒数第二层的末尾元素就是（size - 1 - 1）/ 2

代码实现向下调整建堆就是这样：

//这里是在原数组的基础上建立大堆
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n) {
		if (child + 1 < n && a[child + 1] > a[child])child++;
		if (a[child] > a[parent]) {
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else break;
	}
}

int main()
{
	int arr[] = { 6,5,4,3,2,1,8,7,5,4,2 };
	int size = sizeof(arr) / sizeof(arr[0]);
	for (int i = (size-1-1)/2; i >= 0; i--) {
		AdjustDown(arr, size, i);
	}
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

打印结果和向上调整建堆相同

图解分析此过程：

时间复杂度分析

为什么说向下调整建堆的复杂度更低呢？这确实可以用正规的方式来推一下，证明这不是凭空想象出来的结论。

堆是完全二叉树，满二叉树也是完全二叉树，此处为了简化用直接满二叉树来计算建堆的复杂度（这里实际上多几个结点并不影响，时间复杂度实际计算中计算的也只是一个近似值）

1.向上调整时间复杂度计算

需要移动结点的总步数为：

F(h) = 2^0 * 0 + 2^1 * 1 + 2^2 * 2 +……+ 2^(h-1) * (h - 1)

会发现这是一个等差乘等比的差比数列前n项之和，大家高中应该学过错位相减吧，这里我们用错位相减求和就可以。

1式： 2 * F(h) = 2^1 * 0 + 2^2 * 1 + 2^3 * 2 +……+ 2^h * (h - 1)

2式：F(h) = 2^0 * 0 + 2^1 * 1 + 2^2 * 2 +……+ 2^(h-1) * (h - 1)

1式 - 2式：

F(h) = -2^1 - 2^2 - 2^3 -……-2^(h-1) + 2^h * (h - 1)

上式的加粗部分是一个等比数列，运用等比数列求和公式即可得：

F(h) =  2^h * (h - 2) + 2

而我们又可以导出节点数N和树的深度h之间的关系

N = 2^h-1 ---> h = log(N+1)

带入F(h)中可得

F(N) = (N+1)*[ log(N+1)-2 ] + 2

时间复杂度即为：O(N*logN)

2.向下调整时间复杂度的计算

则需要移动的步数为：

F(h) = 2^0 * (h-1) + 2^1 * (h-2) + …… + 2^(h-3) * 2 + 2^(h-2) * 1

这里也是一个差比数列，列两个式子：
1式：F(h) = 2^0 * (h-1) + 2^1 * (h-2) + …… + 2^(h-3) * 2 + 2^(h-2) * 1

2式：2 * F(h) = 2^1 * (h-1) + 2^2 * (h-2) + …… + 2^(h-2) * 2 + 2^(h-1) * 1

1式 - 2式：

F(h) = 1 - h + 2^1 + 2^2 + 2^3 + 2^4 +……+ 2^(h-2) + 2^(h-1)

等比数列公式一套一化简：

F(h) = 2^h - 1 - h

我们已知N和h之间的关系：N = 2^h-1 ---> h = log(N+1)

最终可得：

F(N) = N -log(N+1)

时间复杂度即为：O(N)

 算到这里，就可以非常轻松的比较出两个方式建堆复杂度的优劣了（向下调整建堆更优）。

堆排序的实现

先放上堆排序代码，再来进行讲解

//堆排序
//交换两个变量
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
//向下调整
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n) {
		if (child + 1 < n && a[child + 1] > a[child])child++;
		if (a[child] > a[parent]) {
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else break;
	}
}
//堆排序
void HeapSort(int* a, int n)
{
    //向下调整建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--) {
		AdjustDown(a, n, i);
	}
    //每次选出一个最大值
	int end = n - 1;
	while (end > 0) {
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}
//使用堆排序
int main()
{
	int arr[] = { 6,5,4,3,2,1,8,7,5,4,2 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
	HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

 可以运行一下看看结果：

你可能会问，代码中建立的是大堆，是怎么排出了由小到大的效果呢？其实这个过程和堆的删除过程是及其相似的

  1. 堆顶存储的是整个堆中最大的元素，当与堆末尾的元素交换之后，最大的元素就成功放到数组的末尾
  2. 通过向下调整之后，堆顶存放的便是堆中第二大的元素
  3. 每次交换堆底都减1（排好的元素不再参与向下调整的过程），这时堆底（新的堆底）和堆顶再次交换，回到步骤1

堆排序的过程其实就是这样（图解）：

这里再次总结，堆排序即利用堆的思想来进行排序，总共分为两个步骤：

1. 建堆

        * 升序：建大堆

        * 降序：建小堆

2. 利用删除思想来进行排序

TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：几十个，几百个，几千个甚至上亿个数字中找到最大的前K个数字。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(你甚至无法将数据放入数组)。最佳的方式就是用堆来解决，基本思路如下：

1. 用数据集合中前k个来建堆

        * 要找最大的前k个元素，建小堆

        * 要找最小的前k个元素，建大堆

2. 用剩余的N - K个元素依次与栈顶元素来比较，不满足则替换堆顶元素向下调整

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素（本topk示例代码中计算的是最大的前K个）。

在这里我们可以用文件操作的方式来试一试，我们先来写一个造数据的函数。

void CreateNDate()
{
	// 造数据
	int n = 10000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}
	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 1000000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
}

这里将造出来的数据写入到 data.txt 文件中，运行完此函数后，当前目录下会多一个data.txt文件

打开此文本文件：

通过此函数，我们已经成功造出了10000个数据了

接下来就是topk代码的实现：

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

//交换函数
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

//向下调整
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n) {
		if (child + 1 < n && a[child + 1] < a[child])child++;
		if (a[child] < a[parent]) {
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else break;
	}
}

//topk代码
void PrintTopK(int k) //这里的k是选出最大的前k个数
{
    //打开需要查找前K大数据的文件---data.txt
	FILE* file = fopen("data.txt", "r");
	if (file == NULL) {
		perror("fopen fail:");
		exit(1);
	}
    //创建存放堆数据的空间
	int* arr = (int*)malloc(sizeof(int) * (k + 1));
	if (arr == NULL) {
		perror("malloc fail:");
		exit(1);
	}
    //输入文件中前k个数据
	for (int i = 0; i < k; i++) {
		fscanf(file, "%d", &arr[i]);
	}
    //将放入的前k个数字调整建堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--) {
		AdjustDown(arr, k, i);
	}
    //这里是topk的重点，遍历K - N的数字，将符合的数字插入堆中
	for (int i = k; i < 10000; i++) {
		int tmp = 0;
		fscanf(file, "%d", &tmp);
        //如果tmp比堆顶的数据大，则放入堆顶向下调整
		if (tmp > arr[0]) {
			arr[0] = tmp;
			AdjustDown(arr, k, 0);
		}
	}
    //打印前K个最大的数字
	for (int i = 0; i < k; i++) {
		printf("%d ", arr[i]);
	}
}

int main()
{
    //输入选前多少大数字
	int digit = 10;
	scanf("%d", &digit);
	PrintTopK(digit);
	return 0;
}

这里，程序成功选出了文件中前100大的数字，如果觉得这样不够严谨，你也可以添加几个位数较高的数据到文件中，看看你的程序能否选出你写入文件的几个特殊的大数字即可。相信在这些测试过后你可以成功感受到topk算法的魅力。

结语

到这里，基本上就是二叉树顺序结构堆的全部内容了，本篇博客带大家学习了解了堆排序，计算了向上调整建堆向下调整建堆的时间复杂度，最后还说到了topk算法。这些内容其实并不难，只要肯下功夫，肯动手，一定能学下来。后面博主还会带大家了解关于二叉树链式结构的内容，欢迎大家多多关注和支持我，比心-♥

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1511231.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python面向对象——程序架构

Python面向对象——程序架构

需求 创建图形管理器 -记录多种图形(圆形、矩形.) --提供计算总面积的方法&#xff0c; 要求:增加新图形&#xff0c;不影响图形管理器 测试: 创建图形管理器&#xff0c;存储多个图形对象。 通过图形管理器&#xff0c;调用计算总面积方法 思路 ​​​​​​​ 代码 # ------…
阅读更多...
C# SM2加解密 ——国密SM2算法

C# SM2加解密 ——国密SM2算法

SM2 是国家密码管理局组织制定并提出的椭圆曲线密码算法标准。 本文使用第三方密码库 BouncyCastle 实现 SM2 加解密&#xff0c;使用 NuGet 安装即可&#xff0c;包名&#xff1a;Portable.BouncyCastle&#xff0c;目前最新版本为&#xff1a;1.9.0。 using Org.BouncyCastl…
阅读更多...
SpringBoot中MD5使用

SpringBoot中MD5使用

SpringBoot中MD5使用 新建md5类 public final class MD5 {public static String encrypt(String strSrc) {try {char[] hexChars {0, 1, 2, 3, 4, 5, 6, 7, 8,9, a, b, c, d, e, f};byte[] bytes strSrc.getBytes();MessageDigest md MessageDigest.getInstance("MD5…
阅读更多...
设计模式前置了解uml图

设计模式前置了解uml图

在开发前&#xff0c;会进行系统的设计&#xff0c;而数据模型的设计大多通过 UML 类图实现。为了在 UML 类图中清晰地表达类之间的关系&#xff0c;需要对类之间的关系有一定的认识&#xff0c;并且了解相关的表达符号。 类之间的关系有以下几种&#xff1a; 组合 聚合 关联…
阅读更多...
IPC：管道

IPC：管道

一、管道的概念 1.原理 在进程3G~4G的内核空间中&#xff0c;创建一个特殊的文件&#xff08;管道&#xff09;&#xff0c;管道的数据直接保存在内存中。 2.特性 1&#xff09;管道可以看成是一个特殊的文件&#xff0c;一般的文件存储在外存中&#xff0c;而管道内容是存储…
阅读更多...
“光谱视界革新：ChatGPT在成像光谱遥感中的智能革命“

“光谱视界革新：ChatGPT在成像光谱遥感中的智能革命“

遥感技术主要通过卫星和飞机从远处观察和测量我们的环境&#xff0c;是理解和监测地球物理、化学和生物系统的基石。ChatGPT是由OpenAI开发的最先进的语言模型&#xff0c;在理解和生成人类语言方面表现出了非凡的能力。本文重点介绍ChatGPT在遥感中的应用&#xff0c;人工智能…
阅读更多...
docker——启动各种服务

docker——启动各种服务

1.Mysql 2.Redis 3.nginx 4.ES 注意&#xff1a;ES7之后环境为 -e ELASTICSEARCH_HOSTS http://ip地址:9200
阅读更多...
双场板功率型GaN HEMT中用于精确开关行为的电容建模

双场板功率型GaN HEMT中用于精确开关行为的电容建模

来源:Capacitance Modeling in Dual Field-Plate Power GaN HEMT for Accurate Switching Behavior (TED 16年) 摘要 本文提出了一种基于表面电势的紧凑模型&#xff0c;用于描述具有栅极和源极场板&#xff08;FP&#xff09;结构的AlGaN/GaN高电子迁移率晶体管&#xff08;…
阅读更多...
在OpenStack架构中，Controller节点的配置（基础）

在OpenStack架构中，Controller节点的配置（基础）

虚拟机的安装 新建虚拟机&#xff0c;选择自定义 默认选择即可 操作系统的镜像稍后选择 客户及操作系统选择Linux&#xff0c;注意选择centos 7 64位 给虚拟机命名 处理器的配置建议1&#xff1a;2 内存大小选择建议为&#xff1a;4GB 网络连接选择为&#xff1a;NAT 默认即可…
阅读更多...
Redis底层核心对象RedisObject源码分析

Redis底层核心对象RedisObject源码分析

文章目录 1. redis底层数据结构2. 插入KV底层源码流程分析 1. redis底层数据结构 redis 6数据结构和底层数据结构的关系 String类型本质是SDS动态字符串&#xff0c;即redis层面的数据结构底层会有对应的数据结构实现&#xff0c;上面是redis 6之前的实现 redis 7数据结构和底…
阅读更多...
如何保证消息的顺序性

如何保证消息的顺序性

先看看顺序会错乱的场景&#xff1a;RabbitMQ&#xff1a;一个 queue&#xff0c;多个 consumer&#xff0c;这不明显乱了&#xff1a; 解决方案&#xff1a;
阅读更多...
基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的番茄新鲜程度检测系统（深度学习+UI界面+训练数据集）

基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的番茄新鲜程度检测系统（深度学习+UI界面+训练数据集）

摘要&#xff1a;本研究详述了一种采用深度学习技术的番茄新鲜程度检测系统&#xff0c;该系统集成了最新的YOLOv8算法&#xff0c;并与YOLOv7、YOLOv6、YOLOv5等早期算法进行了性能评估对比。该系统能够在各种媒介——包括图像、视频文件、实时视频流及批量文件中——准确地识…
阅读更多...
智能泵站智能运维系统

智能泵站智能运维系统

在现代化城市建设和工农业发展中&#xff0c;泵站作为关键的水利设施&#xff0c;其运行效率和稳定性至关重要。然而&#xff0c;传统的泵站运维方式往往依赖于人工巡检和定期维护&#xff0c;这种方式不仅效率低下&#xff0c;而且难以应对突发状况。随着物联网技术的飞速发展…
阅读更多...
支小蜜校园防欺凌系统真的能有效遏制欺凌现象吗？

支小蜜校园防欺凌系统真的能有效遏制欺凌现象吗？

随着社会的快速发展&#xff0c;校园欺凌问题逐渐浮出水面&#xff0c;引起了广泛关注。为了应对这一问题&#xff0c;校园防欺凌系统应运而生&#xff0c;旨在通过一系列措施&#xff0c;有效遏制欺凌现象的发生。然而&#xff0c;这一系统是否真的能够如预期般发挥作用&#…
阅读更多...
软考高项（信息系统项目管理师）备考一、介绍

软考高项（信息系统项目管理师）备考一、介绍

天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物。 每个人都有惰性&#xff0c;但不断学习是好好生活的根本&#xff0c;共勉&#xff01; 文章均为学习整理笔记&#xff0c;分享记录为主&#xff0c;如有错误请指正&#xff0c;共同学习进步。…
阅读更多...
Cassandra 安装部署

Cassandra 安装部署

文章目录 一、概述1.官方文档2. 克隆服务器3.安装准备3.1.安装 JDK 113.2.安装 Python3.3.下载文件 二、安装部署1.配置 Cassandra2.启动 Cassandra3.关闭Cassandra4.查看状态5.客户端连接服务器6.服务运行脚本 开源中间件 # Cassandrahttps://iothub.org.cn/docs/middleware/…
阅读更多...
干货！不懂Python的math模块和random模块操作还不赶紧来学！

干货！不懂Python的math模块和random模块操作还不赶紧来学！

1.导入math模块 import math 2.向上取整&#xff1a;math.ceil() num 9.12print(math.ceil(num)) # 10 3.向下取整&#xff1a;math.floor() num1 9.99print(math.floor(num1)) # 9 4.开平方&#xff1a;math.sqrt()​​​​​​​ num2 16print(math.sqrt(num…
阅读更多...
Python程序控制

Python程序控制

一、程序的描述方式 1.1自然语言 &#xff08;1&#xff09;概念&#xff1a;自然语言就是使用人类语言、直接描述程序 &#xff08;2&#xff09;比如&#xff1a;之前提过的Input&#xff08;输入&#xff09;、Process&#xff08;处理&#xff09;、Output&#xff08;输…
阅读更多...
RabbitMQ - 02 - 基本消息模型

RabbitMQ - 02 - 基本消息模型

目录 部署demo项目 什么是基本消息模型 实现基本消息模型 部署demo项目 首先配置好一个mq的练习demo,并配置好相关依赖 链接&#xff1a;https://pan.baidu.com/s/1oXAqgoz9Y_5V7YxC_rLa-Q?pwdv2sg 提取码&#xff1a;v2sg 如图 父xml文件已经配置好了 AMQP依赖了 什么…
阅读更多...
1.Python是什么？——跟老吕学Python编程

1.Python是什么？——跟老吕学Python编程

1.Python是什么&#xff1f;——跟老吕学Python编程 Python是一种什么样的语言&#xff1f;Python的优点Python的缺点 Python发展历史Python的起源Python版本发展史 Python的价值学Python可以做什么职业&#xff1f;Python可以做什么应用&#xff1f; Python是一种什么样的语言…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023