数据结构-堆排序及其复杂度计算

news2024/11/18 19:54:59

目录

1.堆排序

1.1 向上调整建堆

1.2 向下调整建堆

2. 两种建堆方式的时间复杂度比较

2.1 向下调整建堆的时间复杂度

2.2 向上调整建堆的时间复杂度

Topk问题

上节内容，我们讲了堆的实现，同时还包含了向上调整法和向下调整法，最后我们用堆实现了对数据的排序：

int main()
{
	HP hp;
	HeapInit(&hp);
	int arr[] = { 65,100,70,32,50,60 };
	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		HeapPush(&hp, arr[i]);
	}
	while (!HeapEmpty(&hp))
	{
		HeapDatatype top = HeapTop(&hp);
		printf("%d ", top);
		HeapPop(&hp);
	}
	return 0;
}

那以上代码能实现对数据的排序吗?

答案是可以的，但是以上方式有两个弊端：

1. 要先写一个堆，太麻烦

2. 空间复杂度+拷贝数据。

1.堆排序

上节内容中，用堆对数据进行排序，是将数据一个一个插入堆，然后再调整排序的，那我们能不能直接把数据就建成一个堆？

当然可以，建堆有两种方式：向上调整建堆、向下调整建堆。

1.1 向上调整建堆

我们先来讲向上调整建堆：

向上调整建堆其实还是插入堆的逻辑，要求前面的数据必须是一个堆，下标从1开始是因为一个数据本身就可以被看做一个堆，然后向上调整。 

下图就是我们对一个数组数据进行向上调整建堆后的结果，可以看出来，此时我们建的是一个小堆： 

现在问题来了，我们要把数据排为升序，建大堆还是建小堆好？

先说结论：升序 -- 建大堆    降序 -- 建小堆。 

假设我们要得到升序，此时又建的是小堆，那我们就把选出的最小的数据放在下标为0的位置，要想继续选出次小的数据放在下标为1的位置，就要把剩下的数据看做堆，这样堆的关系就全乱了，只能重新建堆，代价太大。

而如果我们建大堆，向下调整选出最大的数据，首尾交换，把最大的数据放在最后一个下标的位置，然后隔离最后一个数据，把其他数据看做一个堆，再向下调整选出次大的，首尾交换......直到所有的数据被排好序，此时得到的就是数据升序。

代码如下：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

typedef int HeapDatatype;

swap(HeapDatatype* p1, HeapDatatype* p2)
{
	HeapDatatype tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向上调整法
void AdjustUp(HeapDatatype* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[parent] < a[child])
		{
			HeapDatatype p = a[parent];
			a[parent] = a[child];
			a[child] = p;
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[parent] < a[child])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void HeapSort(int* a, int n)
{
	//建堆 - 向上调整建堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}
	//向下调整得到次大数据
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

int main()
{
	int a[] = { 7,8,3,5,1,9,5,4 };
	HeapSort(a, sizeof(a) / sizeof(int));
	return 0;
}

我们建的是大堆，最后得到的就是升序： 

要得到数据降序，就要建小堆，向下调整选出最小的数据，首尾交换，把最小数据放在最后一个下标的位置，隔离最后一个数据，把其他数据看做一个堆，再向下调整选出次小的数据，首尾交换......直到所有数据都被拍好序，这就得到数据降序。

代码如下：（只需将向下调整和向上调整中的'<'改为'>'即可）

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

typedef int HeapDatatype;

swap(HeapDatatype* p1, HeapDatatype* p2)
{
	HeapDatatype tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向上调整法
void AdjustUp(HeapDatatype* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[parent] > a[child])
		{
			HeapDatatype p = a[parent];
			a[parent] = a[child];
			a[child] = p;
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void HeapSort(int* a, int n)
{
	//建堆 - 向上调整建堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}
	//向下调整得到次小数据
	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

int main()
{
	int a[] = { 7,8,3,5,1,9,5,4 };
	HeapSort(a, sizeof(a) / sizeof(int));
	return 0;
}

由于我们建的是小堆，所以得到的就是数据降序： 

注意：不论是升序还是降序，数据都是从后往前放的，这样就不会使堆的关系混乱。 

1.2 向下调整建堆

我们可以看到，堆排序使用向上调整建堆，还要写两个函数：向下调整函数、向上调整函数。

那我们想用一个向下调整函数就解决问题呢？

这就需要向下调整建堆：

向下调整建堆要求根节点的左右子树都是大堆（小堆），如果左右子树不满足大堆，我们只需要确保左右子树的左右子树是大堆（小堆）即可，如果又不是，我们再往下找，所以只要使所有父节点的左右子树都是大堆（小堆）就行，那我们就倒着调整，因为叶子节点本身就是一个堆，所以不需要调整，那就从最后一个节点的父节点开始调整。

代码如下：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

typedef int HeapDatatype;

swap(HeapDatatype* p1, HeapDatatype* p2)
{
	HeapDatatype tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);
			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 a[] = { 7,8,3,5,1,9,5,4 };
	HeapSort(a, sizeof(a) / sizeof(int));
	return 0;
}

代码中int i=(n-1-1)/2是通过孩子找父亲的下标，n是数组大小，先减一得到最后一个下标，再减一除以二得到最后一个孩子的父节点。 

这就是向下调整建堆，以后我们用的都是向下调整建堆，不再使用向上调整建堆，这两种方式不仅代码量上有差距，时间复杂度上也有差距，向下调整建堆的时间复杂度更小。

2. 两种建堆方式的时间复杂度比较

2.1 向下调整建堆的时间复杂度

前文中我们知道了，向下调整建堆要保证每个父节点的左右子树都是大堆（小堆），所以我们在调整的时候是从下往上进行的，而最后一层的每个叶节点本身就可以看做一个堆，不用调整，从它们的父节点开始调整（即倒数第二层开始调整），所以时间复杂度如下：

总步数 = ∑（每一层的节点数*该节点需要调整的层数）

2.2 向上调整建堆的时间复杂度

向上调整和向下调整刚好相反，向下调整时，第h-1行的2^(h-2)个节点需向下调整1层，而向上调整时，第h-1行的2^(h-1)个节点需要向上调整h-2，向下调整是大乘小、小乘大，而向上调整时大乘大、小乘小，时间复杂度如下：

以上就是向上调整建堆和向下调整建堆的时间复杂度，那我们整个堆排序的过程的时间复杂度是多少呢？

堆排序过程中，除了建堆还有向下调整选数，当选数时，要首尾交换，交换一次，从头向下调整一次， 所以第h行的2^(h-1)个节点，每次首尾交换时都要调整(h-1)次，一共2^(h-1)*(h-1)，由此可见，选数据过程中的时间复杂度和向上调整建堆的时间复杂度保持一致，即为O(N*logN)

所以堆排序整体的时间复杂度是：建堆+选数 = O(N+N*logN)，即O(N*logN)。

Topk问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

1. 用数据集合中前K个元素来建堆
前k个最大的元素，则建小堆
前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

比如：我们要找10000个数中的前K个最小的数，就把先把前K个数建小堆，然后把用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素 

代码如下：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<time.h>
#include<stdlib.h>

//Top-K问题
typedef int HeapDatatype;

swap(HeapDatatype* p1, HeapDatatype* p2)
{
	HeapDatatype tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整法
void AdjustDown(HeapDatatype* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
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);
}

void PrintTopK(int k)
{
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc error");
		return;
	}

	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &kminheap[i]);
	}

	// 建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(kminheap, k, i);
	}

	int val = 0;
	while (!feof(fout))
	{
		fscanf(fout, "%d", &val);
		if (val > kminheap[0])
		{
			kminheap[0] = val;
			AdjustDown(kminheap, k, 0);
		}
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}


int main()
{
	CreateNDate();
	PrintTopK(5);
	return 0;
}

关于堆排序的所有内容已经学完了，下节我们继续讲二叉树的前序、中序、后序和层序。

未完待续。。。

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

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

相关文章

为什么要安装田间气象站？

为什么要安装田间气象站？

随着农业科技的发展&#xff0c;越来越多的农民朋友开始关注如何利用科技手段来提高农业生产效益。其中&#xff0c;安装田间气象站成为了许多农民朋友的选择之一&#xff0c;为什么会有这种情况呢&#xff1f;安装田间气象站会带来哪些优势呢&#xff1f; 一、了解气候变化 气…
阅读更多...
Vue3问题：如何实现页面引导提示？

Vue3问题：如何实现页面引导提示？

前端功能问题系列文章&#xff0c;点击上方合集↑ 序言 大家好&#xff0c;我是大澈&#xff01; 本文约1700字&#xff0c;整篇阅读大约需要3分钟。 本文主要内容分三部分&#xff0c;第一部分是需求分析&#xff0c;第二部分是实现步骤&#xff0c;第三部分是问题详解。 …
阅读更多...
No194.精选前端面试题，享受每天的挑战和学习

No194.精选前端面试题，享受每天的挑战和学习

🤍 前端开发工程师（主业）、技术博主（副业）、已过CET6 🍨 阿珊和她的猫_CSDN个人主页 🕠 牛客高级专题作者、在牛客打造高质量专栏《前端面试必备》 🍚 蓝桥云课签约作者、已在蓝桥云课上架的前后端实战课程《Vue.js 和 Egg.js 开发企业级健康管理项目》、《带你从入…
阅读更多...
C语言--假设共有鸡、兔30只，脚90只，求鸡、兔各有多少只​

C语言--假设共有鸡、兔30只，脚90只，求鸡、兔各有多少只​

一.题目描述 假设共有鸡、兔30只&#xff0c;脚90只&#xff0c;求鸡、兔各有多少只&#xff1f; 二.思路分析 本题是一个典型的穷举法例题&#xff0c;而穷举法&#xff0c;最重要的就是条件判断。⭐⭐ 本题中的条件很容易发现&#xff1a; 假设鸡有x只&#xff0c;兔有y只…
阅读更多...
【C++类和对象下：解锁面向对象编程的奇妙世界】

【C++类和对象下：解锁面向对象编程的奇妙世界】

【本节目标】 1. 再谈构造函数 2. Static成员 3. 友元 4. 内部类 5.匿名对象 6.拷贝对象时的一些编译器优化 7. 再次理解封装 1. 再谈构造函数 1.1 构造函数体赋值 在创建对象时&#xff0c;编译器通过调用构造函数&#xff0c;给对象中各个成员变量一个合适的初始值。…
阅读更多...
Matlab论文插图绘制模板第126期—分组三维气泡图

Matlab论文插图绘制模板第126期—分组三维气泡图

在之前的文章中&#xff0c;分享了Matlab三维气泡图的绘制模板&#xff1a; 特征渲染的三维气泡图&#xff1a; 进一步&#xff0c;再来分享一下分组三维气泡图。 先来看一下成品效果&#xff1a; 特别提示&#xff1a;本期内容『数据代码』已上传资源群中&#xff0c;加群的朋…
阅读更多...
java8函数式编程(Lambda表达式，Optional，Stream流)从入门到精通

java8函数式编程(Lambda表达式，Optional，Stream流)从入门到精通

文章目录 函数式编程Lambda表达式Stream流创建流中间操作终结操作注意事项 Optional创建对象消费值获取值过滤判断数据转换 方法引用高级用法基本数据类型优化并行流 函数式编程 不关心具体的对象&#xff0c;只关心数据参数和 具体操作 Lambda表达式 格式&#xff1a; () -&…
阅读更多...
基于缎蓝园丁鸟算法优化概率神经网络PNN的分类预测 - 附代码

基于缎蓝园丁鸟算法优化概率神经网络PNN的分类预测 - 附代码

基于缎蓝园丁鸟算法优化概率神经网络PNN的分类预测 - 附代码 文章目录 基于缎蓝园丁鸟算法优化概率神经网络PNN的分类预测 - 附代码1.PNN网络概述2.变压器故障诊街系统相关背景2.1 模型建立 3.基于缎蓝园丁鸟优化的PNN网络5.测试结果6.参考文献7.Matlab代码 摘要&#xff1a;针…
阅读更多...
css3 初步了解

css3 初步了解

1、css3的含义及简介 简而言之&#xff0c;css3 就是 css的最新标准&#xff0c;使用css3都要遵循这个标准&#xff0c;CSS3 已完全向后兼容&#xff0c;所以你就不必改变现有的设计&#xff0c; 2、一些比较重要的css3 模块 选择器 1、标签选择器&#xff0c;也称为元素选择…
阅读更多...
C++算法： 最大化数组末位元素的最少操作次数

C++算法： 最大化数组末位元素的最少操作次数

涉及知识点 数学 题目 给你两个下标从 0 开始的整数数组 nums1 和 nums2 &#xff0c;这两个数组的长度都是 n 。 你可以执行一系列 操作&#xff08;可能不执行&#xff09;。 在每次操作中&#xff0c;你可以选择一个在范围 [0, n - 1] 内的下标 i &#xff0c;并交换 num…
阅读更多...
MyBatis 知识总结

MyBatis 知识总结

1 MyBatis 1.1 简介 持久层框架&#xff0c;用于简化JDBC开发 JavaEE三层架构&#xff1a;表现层、业务层、持久层 表现层&#xff1a;做页面展示 业务层&#xff1a;做逻辑处理 持久层&#xff1a;负责将数据保存到数据库的那一层代码 框架&#xff1a;半成品软件&#xff0…
阅读更多...
软件外包开发的需求对接

软件外包开发的需求对接

软件外包开发的成功与否很大程度上取决于需求对接的有效性。以下是一些建议&#xff0c;可帮助您在软件外包开发中进行需求对接&#xff0c;希望对大家有所帮助。北京木奇移动技术有限公司&#xff0c;专业的软件外包开发公司&#xff0c;欢迎交流合作。 1.明确业务目标和需求&…
阅读更多...
CSDN每日一题学习训练——Java版（字符串相乘、子集、删除链表的倒数第 N 个结点）

CSDN每日一题学习训练——Java版（字符串相乘、子集、删除链表的倒数第 N 个结点）

版本说明 当前版本号[20231112]。 版本修改说明20231112初版 目录 文章目录 版本说明目录字符串相乘题目解题思路代码思路补充说明参考代码 子集题目解题思路代码思路参考代码 删除链表的倒数第 N 个结点题目解题思路代码思路参考代码 字符串相乘 题目 给定两个以字符串形…
阅读更多...
解决谷歌浏览器卸载后重装失败谷歌浏览器无法更新

解决谷歌浏览器卸载后重装失败谷歌浏览器无法更新

一.谷歌浏览器卸载后重装失败 大多数情况都是卸载残留导致的。所以要去清理注册表。 winR&#xff0c;然后输入regedit&#xff0c;启动注册表&#xff0c;HKEY_CURRENT_USER/HKEY_CURRENT_USER/Software中的Google文件夹删除即可&#xff0c;然后重启电脑&#xff0c;如果还…
阅读更多...
二、数据运营：B-O价值模型

二、数据运营：B-O价值模型

B - O 价值模型&#xff0c;即 Business - Operation 模型&#xff0c;业务一运营模型。这是一个非常成熟的概念&#xff0c;其变体 BOSS 系统&#xff0c;即 BSS 业务支撑系统和 OSS 运营支撑系统已经在通信运营上使用20多年之久。 B - O 价值模型试图建立起一种通用的业务经…
阅读更多...
工作记录--（用HTTPS，为啥能被查出浏览记录？如何解决？）---每天学习多一点

工作记录--（用HTTPS，为啥能被查出浏览记录？如何解决？）---每天学习多一点

由于网络通信有很多层&#xff0c;即使加密通信&#xff0c;仍有很多途径暴露你的访问地址&#xff0c;比如&#xff1a; DNS查询&#xff1a;通常DNS查询是不会加密的&#xff0c;所以&#xff0c;能看到你DNS查询的观察者&#xff08;比如运营商&#xff09;是可以推断出访问…
阅读更多...
区块链拆分

区块链拆分

随着区块链技术的发展和普及&#xff0c;去中心化钱包逐渐成为数字货币领域的重要工具。去中心化钱包不仅具有高度安全性和隐私保护能力&#xff0c;还可以通过智能合约和开源技术实现定制化功能。本文将探讨去中心化钱包定制开发的基本概念、优势、流程和前景。 一、去中心化钱…
阅读更多...
Linux下的文件系统

Linux下的文件系统

文章目录 一、初始文件系统 二、理解磁盘文件 三、了解磁盘 四、深入理解磁盘文件 4、1 磁盘分区 4、2 分区存储细节 4、3 磁盘文件的操作 4、3、1 查找某个磁盘文件 4、3、2 创建文件 4、3、3 对文件进行写入 4、3、4 删除文件 4、4 再次理解文件权限 &#x1f64b;‍♂️ 作…
阅读更多...
MCU通过KT6368A用SPP透传发送1K左右的数据，手机APP显示是3个包或者4个包，但是我看手册说最大一个包是512，理论应该是两个包吧，请问这正常吗？

MCU通过KT6368A用SPP透传发送1K左右的数据，手机APP显示是3个包或者4个包，但是我看手册说最大一个包是512，理论应该是两个包吧，请问这正常吗？

一、问题简介 MCU通过KT6368A用SPP透传发送1K左右的数据&#xff0c;手机APP显示是3个包或者4个包&#xff0c;但是我看手册说最大一个包是512&#xff0c;理论应该是两个包吧&#xff0c;请问这正常吗&#xff1f; 详细说明 实际测试的截图如下&#xff1a;使用的是安卓app…
阅读更多...
【设计原则篇】聊聊开闭原则

【设计原则篇】聊聊开闭原则

开闭原则 其实就是对修改关闭&#xff0c;对拓展开放。 是什么 OCP&#xff08;Open/Closed Principle&#xff09;- 开闭原则。关于开发封闭原则&#xff0c;其核心的思想是&#xff1a;模块是可扩展的&#xff0c;而不可修改的。也就是说&#xff0c;对扩展是开放的&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023