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

成屿2023-11-14 10:35

目录

1.堆排序

[1.1 向上调整建堆](#1.1 向上调整建堆)

[1.2 向下调整建堆](#1.2 向下调整建堆)

[2. 两种建堆方式的时间复杂度比较](#2. 两种建堆方式的时间复杂度比较)

[2.1 向下调整建堆的时间复杂度](#2.1 向下调整建堆的时间复杂度)

[2.2 向上调整建堆的时间复杂度](#2.2 向上调整建堆的时间复杂度)

Topk问题

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

cpp 复制代码 
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的位置，就要把剩下的数据看做堆，这样堆的关系就全乱了，只能重新建堆，代价太大。

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

代码如下：

cpp 复制代码 
#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;
}

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

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

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

cpp 复制代码 
#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 向下调整建堆

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

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

这就需要向下调整建堆：

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

代码如下：

cpp 复制代码 
#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个元素依次与堆顶元素来比较，不满足则替换堆顶元素

代码如下：

cpp 复制代码 
#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;
}

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

未完待续。。。

相关推荐
shymoy5 分钟前
Radix Sorts
数据结构·算法·排序算法
木向1 小时前
leetcode92:反转链表||
数据结构·c++·算法·leetcode·链表
阿阿越1 小时前
算法每日练 -- 双指针篇（持续更新中）
数据结构·c++·算法
小爬虫程序猿4 小时前
如何利用Python解析API返回的数据结构？
数据结构·数据库·python
pianmian18 小时前
python数据结构基础(7)
数据结构·算法
ChoSeitaku11 小时前
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
数据结构·考研·链表
偷心编程11 小时前
双向链表专题
数据结构
香菜大丸11 小时前
链表的归并排序
数据结构·算法·链表
jrrz082811 小时前
LeetCode 热题100（七）【链表】（1）
数据结构·c++·算法·leetcode·链表
@小博的博客12 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测05RAG 实践- Ollama+RagFlow 部署本地知识库06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08【Java】Ruoyi-Vue-Plus 整合 文件分片上传至 minio、阿里云、七牛云等OSS-【后端篇】09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除