• 【数据结构】堆，堆的实现，堆排序，TOP-K问题

    大家好！今天我们来学习数据结构中的堆及其应用

    目录

    1. 堆的概念及结构

    2. 堆的实现

    2.1 初始化堆

    2.2 销毁堆

    2.3 打印堆

    2.4 交换函数

    2.5 堆的向上调整

    2.6 堆的向下调整

    2.7 堆的插入

    2.8 堆的删除

    2.9 取堆顶的数据

    2.10 堆的数据个数

    2.11 堆的判空

    3. 堆的实现的完整代码

    3.1 Heap.h

    3.2 Heap.c

    3.3 Test.c

    4. 建堆的时间复杂度

    4.1 向上调整建堆

    4.2 向下调整建堆

    5. 堆的应用

    5.1 堆排序

    5.2 TOP-K问题

    6. 总结

    1. 堆的概念及结构

    堆(Heap)是计算机科学中中一类特殊的数据结构，是最高效的优先级队列，堆通常是一个可以被看作一棵完全二叉树的数组对象。

    堆分为最小堆（Min Heap）和 最大堆（Max Heap）。对于最小堆，父结点的值小于等于它的子结点的值。对于最大堆，父结点的值大于等于它的子结点的值；

    堆的性质：

    1. 堆中某个结点的值总是不大于或不小于其父结点的值。

    2. 堆总是一棵完全二叉树。

    3. 小堆的根是整棵树的最小值，大堆的根是整棵树的最大值。

    问题：

    1. 小堆的底层数组是否升序？

    2. 大堆的底层数组是否降序？

    2. 堆的实现

    我们这里以小根堆为例（大根堆可以在小根堆的基础上稍作修改），下面是要实现堆的接口函数：

    1. //初始化堆
    2. void HeapInit(HP* php);
    3. //销毁堆
    4. void HeapDestroy(HP* php);
    5. //打印堆
    6. void HeapPrint(HP* php);
    7. //交换函数
    8. void Swap(HPDataType* p1, HPDataType* p2);
    9. //堆向上调整算法
    10. void AdjustUp(HPDataType* a, int child);
    11. //堆向下调整算法
    12. void AdjustDown(HPDataType* a, int n, int parent);
    13. //堆的插入
    14. void HeapPush(HP* php, HPDataType x);
    15. //堆的删除
    16. void HeapPop(HP* php);
    17. //取堆顶的数据
    18. HPDataType HeapTop(HP* php);
    19. //堆的数据个数
    20. int HeapSize(HP* php);
    21. //堆的判空
    22. bool HeapEmpty(HP* php);

    堆的定义：

    1. typedef int HPDataType;
    2. typedef struct Heap
    3. {
    4. 	HPDataType* a;
    5. 	int size;
    6. 	int capacity;
    7. }HP;

    一些简单的接口函数，和我们之前实现的顺序表，链表，栈等数据结构类似。我们在这里就不详细介绍了，这里我们主要介绍堆向上调整算法和堆向下调整算法。这两个函数分别会在堆的插入和堆的删除中调用。

    2.1 初始化堆

    1. //初始化堆
    2. void HeapInit(HP* php)
    3. {
    4. 	assert(php);
    5. 	php->a = NULL;
    6. 	php->size = 0;
    7. 	php->capacity = 0;
    8. }

    2.2 销毁堆

    1. //销毁堆
    2. void HeapDestroy(HP* php)
    3. {
    4. 	assert(php);
    5. 	free(php->a);
    6. 	php->a = NULL;
    7. 	php->size = php->capacity = 0;
    8. }

    2.3 打印堆

    1. //打印堆
    2. void HeapPrint(HP* php)
    3. {
    4. 	assert(php);
    5. 	for (int i = 0; i < php->size; i++)
    6. 	{
    7. 		printf("%d ", php->a[i]);
    8. 	}
    9. 	printf("\n");
    10. }

    2.4 交换函数

    1. //交换函数
    2. void Swap(HPDataType* p1, HPDataType* p2)
    3. {
    4. 	HPDataType tmp = *p1;
    5. 	*p1 = *p2;
    6. 	*p2 = tmp;
    7. }

    2.5 堆的向上调整

    向上调整前提：前面的数据是堆

    1. //堆向上调整算法
    2. void AdjustUp(HPDataType* a, int child)
    3. {
    4. 	int parent = (child - 1) / 2;
    5. 	while (child > 0)
    6. 	{
    7. 		if (a[child] < a[parent])
    8. 		{
    9. 			Swap(&a[child], &a[parent]);
    10. 			child = parent;
    11. 			parent = (parent - 1) / 2;
    12. 		}
    13. 		else 
    14. 		{
    15. 			break;
    16. 		}	
    17. 	}
    18. }

    2.6 堆的向下调整

    向下调整前提：左右子树都是小堆或者都是大堆

    1. //堆向下调整算法
    2. void AdjustDown(HPDataType* a, int n, int parent)
    3. {
    4. 	int child = parent * 2 + 1;
    5. 	while (child < n)
    6. 	{
    7. 		if (child + 1 < n && a[child + 1] < a[child]) //找出小的那个孩子
    8. 		{
    9. 			++child;
    10. 		}
    11. 		if (a[child] < a[parent])
    12. 		{
    13. 			Swap(&a[child], &a[parent]);
    14. 			parent = child; 
    15. 			child = parent * 2 + 1;
    16. 		}
    17. 		else
    18. 		{
    19. 			break;
    20. 		}
    21. 	}
    22. }

    2.7 堆的插入

    向堆中插入一个元素，就是这个元素插入到堆的尾部，因为堆的实际存储结构是一个数组，我们可以将元素放到数组末尾。

    但是如果仅仅是将元素插入到数组末尾的话，会破坏堆的结构，我们还需要调用一个向上调整函数，保持堆的结构。

    注意：在插入之前，我们需要判断堆的容量是否足够，如果堆的容量已满，需要扩容，扩容时我们在原来的基础上扩2倍。

    如下图：

    先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

    1. //堆的插入
    2. void HeapPush(HP* php, HPDataType x)
    3. {
    4. 	assert(php);
    5. 	if (php->size == php->capacity)
    6. 	{
    7. 		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    8. 		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newCapacity);
    9. 		if (tmp == NULL)
    10. 		{
    11. 			perror("realloc failed");
    12. 			exit(-1);
    13. 		}
    14. 		php->a = tmp;
    15. 		php->capacity = newCapacity;
    16. 	}
    17. 	php->a[php->size] = x;
    18. 	php->size++;
    19. 	AdjustUp(php->a, php->size - 1);
    20. }

    2.8 堆的删除

    删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

    1. //堆的删除
    2. void HeapPop(HP* php)
    3. {
    4. 	assert(php);
    5. 	assert(php->size > 0);
    6. 	Swap(&php->a[0], &php->a[php->size - 1]);
    7. 	--php->size;
    8. 	AdjustDown(php->a, php->size, 0);
    9. }

    2.9 取堆顶的数据

    1. //取堆顶的数据
    2. HPDataType HeapTop(HP* php)
    3. {
    4. 	assert(php);
    5. 	assert(php->size > 0);
    6. 	return php->a[0];
    7. }

    2.10 堆的数据个数

    1. //堆的数据个数
    2. int HeapSize(HP* php) 
    3. {
    4. 	assert(php);
    5. 	return php->size;
    6. }

    2.11 堆的判空

    1. //堆的判空
    2. bool HeapEmpty(HP* php)
    3. {
    4. 	assert(php);
    5. 	return php->size == 0;
    6. }

    3. 堆的实现的完整代码

    3.1 Heap.h

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. typedef int HPDataType;
    8. typedef struct Heap
    9. {
    10. 	HPDataType* a;
    11. 	int size;
    12. 	int capacity;
    13. }HP;
    14.  
    15.  
    16. //初始化堆
    17. void HeapInit(HP* php);
    18. //销毁堆
    19. void HeapDestroy(HP* php);
    20. //打印堆
    21. void HeapPrint(HP* php);
    22. //交换函数
    23. void Swap(HPDataType* p1, HPDataType* p2);
    24. //堆向上调整算法
    25. void AdjustUp(HPDataType* a, int child);
    26. //堆向下调整算法
    27. void AdjustDown(HPDataType* a, int n, int parent);
    28. //堆的插入
    29. void HeapPush(HP* php, HPDataType x);
    30. //堆的删除
    31. void HeapPop(HP* php);
    32. //取堆顶的数据
    33. HPDataType HeapTop(HP* php);
    34. //堆的数据个数
    35. int HeapSize(HP* php);
    36. //堆的判空
    37. bool HeapEmpty(HP* php);

    3.2 Heap.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"Heap.h"
    3.  
    4. //初始化堆
    5. void HeapInit(HP* php)
    6. {
    7. 	assert(php);
    8. 	php->a = NULL;
    9. 	php->size = 0;
    10. 	php->capacity = 0;
    11. }
    12.  
    13. //销毁堆
    14. void HeapDestroy(HP* php)
    15. {
    16. 	assert(php);
    17. 	free(php->a);
    18. 	php->a = NULL;
    19. 	php->size = php->capacity = 0;
    20. }
    21.  
    22. //打印堆
    23. void HeapPrint(HP* php)
    24. {
    25. 	assert(php);
    26. 	for (int i = 0; i < php->size; i++)
    27. 	{
    28. 		printf("%d ", php->a[i]);
    29. 	}
    30. 	printf("\n");
    31. }
    32.  
    33. //交换函数
    34. void Swap(HPDataType* p1, HPDataType* p2)
    35. {
    36. 	HPDataType tmp = *p1;
    37. 	*p1 = *p2;
    38. 	*p2 = tmp;
    39. }
    40.  
    41. //堆向上调整算法
    42. void AdjustUp(HPDataType* a, int child)
    43. {
    44. 	int parent = (child - 1) / 2;
    45. 	while (child > 0)
    46. 	{
    47. 		if (a[child] < a[parent])
    48. 		{
    49. 			Swap(&a[child], &a[parent]);
    50. 			child = parent;
    51. 			parent = (parent - 1) / 2;
    52. 		}
    53. 		else 
    54. 		{
    55. 			break;
    56. 		}	
    57. 	}
    58. }
    59.  
    60. //堆向下调整算法
    61. void AdjustDown(HPDataType* a, int n, int parent)
    62. {
    63. 	int child = parent * 2 + 1;
    64. 	while (child < n)
    65. 	{
    66. 		if (child + 1 < n && a[child + 1] < a[child]) //找出小的那个孩子
    67. 		{
    68. 			++child;
    69. 		}
    70. 		if (a[child] < a[parent])
    71. 		{
    72. 			Swap(&a[child], &a[parent]);
    73. 			parent = child; 
    74. 			child = parent * 2 + 1;
    75. 		}
    76. 		else
    77. 		{
    78. 			break;
    79. 		}
    80. 	}
    81. }
    82.  
    83. //堆的插入
    84. void HeapPush(HP* php, HPDataType x)
    85. {
    86. 	assert(php);
    87. 	if (php->size == php->capacity)
    88. 	{
    89. 		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    90. 		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newCapacity);
    91. 		if (tmp == NULL)
    92. 		{
    93. 			perror("realloc failed");
    94. 			exit(-1);
    95. 		}
    96. 		php->a = tmp;
    97. 		php->capacity = newCapacity;
    98. 	}
    99. 	php->a[php->size] = x;
    100. 	php->size++;
    101. 	AdjustUp(php->a, php->size - 1);
    102. }
    103.  
    104. //堆的删除
    105. void HeapPop(HP* php)
    106. {
    107. 	assert(php);
    108. 	assert(php->size > 0);
    109. 	Swap(&php->a[0], &php->a[php->size - 1]);
    110. 	--php->size;
    111. 	AdjustDown(php->a, php->size, 0);
    112. }
    113.  
    114. //取堆顶的数据
    115. HPDataType HeapTop(HP* php)
    116. {
    117. 	assert(php);
    118. 	assert(php->size > 0);
    119. 	return php->a[0];
    120. }
    121.  
    122. //堆的数据个数
    123. int HeapSize(HP* php) 
    124. {
    125. 	assert(php);
    126. 	return php->size;
    127. }
    128.  
    129. //堆的判空
    130. bool HeapEmpty(HP* php)
    131. {
    132. 	assert(php);
    133. 	return php->size == 0;
    134. }

    3.3 Test.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"Heap.h"
    3.  
    4. int main()
    5. {
    6. 	int a[] = { 2,3,5,7,4,6,8};
    7. 	HP hp;
    8. 	HeapInit(&hp);
    9. 	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    10. 	{
    11. 		HeapPush(&hp, a[i]);
    12. 	}
    13. 	HeapPrint(&hp);
    14. 	int sz = HeapSize(&hp);
    15. 	printf("堆中元素个数为%d个\n", sz);
    16. 	
    17. 	while (!HeapEmpty(&hp))
    18. 	{
    19. 		printf("%d ", HeapTop(&hp));
    20. 		HeapPop(&hp);
    21. 	}
    22. 	HeapDestroy(&hp);
    23. 	return 0;
    24. }

    4. 建堆的时间复杂度

    因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个结点不影响最终结果)：

    4.1 向上调整建堆

    因此向上调整建堆的时间复杂度是O(N*logN)

    4.2 向下调整建堆

    因此，向下调整建堆的时间复杂度为O(N)

    因为向下调整建堆的时间复杂度是O(N)，小于向上调整建堆的时间复杂度O(N*logN)，所以一般情况下，我们都采用向下调整建堆。

    5. 堆的应用

    5.1 堆排序

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

    1. 建堆

    升序：建大堆

    降序：建小堆

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

    建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

    这里我们以大堆为例，通过堆排序进行升序

    我们也可以在堆的底层数组中进一步理解堆排序的过程

    因为是大堆，所以我们要稍微修改向下调整部分的代码（我们在上面堆的实现中是以小堆为例）

    1. void Swap(HPDataType* p1, HPDataType* p2)
    2. {
    3. 	HPDataType tmp = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = tmp;
    6. }
    7.  
    8. void AdjustDown(HPDataType* a, int n, int parent)
    9. {
    10. 	int child = parent * 2 + 1;
    11. 	while (child < n)
    12. 	{
    13. 		if (child + 1 < n && a[child + 1] > a[child]) //找出大的那个孩子
    14. 		{
    15. 			++child;
    16. 		}
    17. 		if (a[child] > a[parent])
    18. 		{
    19. 			Swap(&a[child], &a[parent]);
    20. 			parent = child; 
    21. 			child = parent * 2 + 1;
    22. 		}
    23. 		else
    24. 		{
    25. 			break;
    26. 		}
    27. 	}
    28. }
    1. void HeapSort(int* a, int n)
    2. {
    3. 	//从倒数第一个非叶子结点开始调
    4. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    5. 	{
    6. 		AdjustDown(a, n, i);  //向下调整建堆
    7. 	}
    8. 	int end = n - 1;
    9. 	while (end > 0)
    10. 	{
    11. 		Swap(&a[0], &a[end]);
    12. 		AdjustDown(a, end, 0);  //向下调整[0,end]的元素
    13. 		--end;
    14. 	}
    15. }
    16.  
    17. int main()
    18. {
    19. 	int a[] = { 20,17,4,16,5,3 };
    20. 	HeapSort(a, sizeof(a) / sizeof(int));
    21. 	for (int i=0 ; i < sizeof(a) / sizeof(int); i++)
    22. 	{
    23. 		printf("%d ", a[i]);
    24. 	}
    25. 	printf("\n");
    26. 	return 0;
    27. }

    5.2 TOP-K问题

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

    比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

    对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

    1. 用数据集合中前K个元素来建堆

    前k个最大的元素，则建小堆

    前k个最小的元素，则建大堆

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

    将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

    实际应用：在1000000个随机数中找出前十个最大的数字

    1. void PrintTopK(int* a, int n, int k)
    2. {
    3. 	int* KMaxHeap = (int*)malloc(sizeof(int) * k);
    4. 	assert(KMaxHeap);
    5. 	for (int i = 0; i < k; i++)
    6. 	{
    7. 		KMaxHeap[i] = a[i];
    8. 	}
    9. 	//建小根堆
    10. 	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
    11. 	{
    12. 		AdjustDown(KMaxHeap, k, i);
    13. 	}
    14. 	//依次比较a数组中剩余的元素
    15. 	for (int i = k; i < n; i++)
    16. 	{
    17. 		if (a[i] > KMaxHeap[0])
    18. 		{
    19. 			KMaxHeap[0] = a[i];
    20. 		}
    21. 		AdjustDown(KMaxHeap, k, 0);
    22. 	}
    23. 	//打印
    24. 	for (int i = 0; i < k; i++)
    25. 	{
    26. 		printf("%d ", KMaxHeap[i]);
    27. 	}
    28. 	printf("\n");
    29. }
    30.  
    31. void TestTopK()
    32. {
    33. 	int n = 1000000;
    34. 	int* a = (int*)malloc(sizeof(int) * n);
    35. 	srand(time(0));
    36. 	for (int i = 0; i < n; i++)
    37. 	{
    38. 		a[i] = rand() % n;
    39. 	}
    40. 	//手动设定10个最大的数
    41. 	a[5] = n + 1;
    42. 	a[1231] = n + 2;
    43. 	a[531] = n + 3;
    44. 	a[5121] = n + 4;
    45. 	a[115] = n + 5;
    46. 	a[2335] = n + 6;
    47. 	a[9999] = n + 7;
    48. 	a[76] = n + 8;
    49. 	a[423] = n + 9;
    50. 	a[3144] = n + 10;
    51. 	PrintTopK(a, n, 10);
    52. }
    53.  
    54. int main()
    55. {
    56. 	TestTopK();
    57. 	return 0;
    58. }

    6. 总结

    到这里，我们就用学习完了数据结构中堆的相关知识点。有什么问题欢迎在评论区讨论。如果觉得文章有什么不足之处，可以在评论区留言。如果喜欢我的文章，可以点赞收藏哦！

  • 相关阅读:
    flutter系列之:做一个下载按钮的动画
    猿创征文 | 【Java进阶】详解抽象类及常用接口
    【Qt6】列表模型——树形列表
    设计模式之工厂方法模式--更加符合开闭原则的工厂模式
    STM32CubeMX学习笔记3-串口通信2（不定长数据）
    MAUI 初体验 联合 WinForm 让家里废弃的手机当做电脑副品用起来
    基于 IP 的 DDOS 攻击实验
    spring boot集成MockMvc进行集成测试小案例
    基于JAVA,SpringBoot和HTML校园二手商城系统设计
    【推荐系统】geohash召回
  • 原文地址：https://blog.csdn.net/m0_62531913/article/details/132914673