• 数据结构——【堆】

    一、堆的相关概念

    1.1、堆的概念

    1、堆在逻辑上是一颗完全二叉树（类似于一颗满二叉树只缺了右下角）。

    2、堆的实现利用的是数组，我们通常会利用动态数组来存放元素，这样可以快速拓容也不会很浪费空间，我们是将这颗完全二叉树用层序遍历的方式储存在数组里的。

    3、堆有两种分别是大根堆和小根堆 。

    1.2、堆的分类

    1.2.1、大根堆

    大根堆就是整个完全二叉树，任意一个根节点的值都比左右子树的值大    

              

    这就是一个大根堆，所有根节点的值永远比左右子树的大，那么就可以看出，整棵树的根节点，他的值是整个堆中最大的。同时我们也发现没有直接父子关系的节点他们的值没有完全地关系，就像第二层的33和第三层的45以及20，没有规定第三层的元素值必须小于第二层，只要满足根节点比自己左右子树节点的值大即可。

    1.2.3、小根堆

    小根堆表示整个完全二叉树，任意一个根节点的值都比左右子树的值小。

                

    以上就是一个简单地小根堆它的定义与大根堆相似，只是跟节点的值小于自己的左右节点的值，同时小根堆的层与层之间没有直接关系的节点的值也没有必然的大小关系。

    1.3、堆的结构

    堆的逻辑结构是一颗完全二叉树

    堆的物理结构是一个数组

    我们可以用左右孩子节点和父节点，来表示所有的节点。

    leftchild = parent * 2 + 1;

    rightchild = parent * 2 + 2;

    parent = (child - 1) / 2;(child可以是左孩子,也可以是右孩子)

     如下图：是一个大根堆，父节点的值都大于子节点的值。

    在数组中存储的是：

    109 865743

    二、堆的实现

    2.1、堆的功能

    我们是以顺序表的形式实现的堆，其中基本的操作和顺序表的操作是大致一样的。

    下面是我们要实现的堆的一些基础功能

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

    2.2、堆函数的实现

    1. #include"Heap.h"
    2.  
    3. //初始堆
    4. void HeapInit(Heap* hp)
    5. {
    6. 	assert(hp);
    7. 	hp->a = NULL;
    8. 	hp->size = 0;
    9. 	hp->capacity = 0;
    10. }
    11.  
    12. // 堆的销毁
    13. void HeapDestory(Heap* hp)
    14. {
    15. 	assert(hp);
    16.  
    17. 	free(hp->a);
    18. 	hp->a = NULL;
    19.  
    20. 	hp->size = hp->capacity = 0;
    21. }
    22.  
    23. //交换函数
    24. void Swap(HPDataType* p1, HPDataType* p2)
    25. {
    26. 	HPDataType temp = *p1;
    27. 	*p1 = *p2;
    28. 	*p2 = temp;
    29. }
    30.  
    31. //向上调整（前面的是堆）
    32. void AdjustUp(HPDataType* a, int child)
    33. {
    34. 	int parent = (child - 1) / 2;
    35. 	while (child > 0)
    36. 	{
    37. 		//小堆
    38. 		if (a[child] <  a[parent])
    39. 		{
    40. 			Swap(&a[child], &a[parent]);
    41. 			child = parent;
    42. 			parent = (parent - 1) / 2;
    43.  
    44. 		}
    45. 		else
    46. 		{
    47. 			break;
    48. 		}
    49. 	}
    50. }
    51.  
    52. //打印堆
    53. void HeapPrint(Heap* hp)
    54. {
    55. 	assert(hp);
    56. 	for (size_t i = 0; i < hp->size; i++)
    57. 	{
    58. 		printf("%d ",hp->a[i]);
    59. 	}
    60. 	printf("\n");
    61. }
    62.  
    63. // 堆的插入
    64. void HeapPush(Heap* hp, HPDataType x)
    65. {
    66. 	assert(hp);
    67. 	if (hp->size == hp->capacity)
    68. 	{
    69. 		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
    70. 		HPDataType* tem = (HPDataType*)realloc(hp->a,sizeof(HPDataType)*newcapacity);
    71. 		if (tem == NULL)
    72. 		{
    73. 			perror("malloc fail");
    74. 			exit(-1);
    75. 		}
    76. 		hp->a = tem;
    77. 		hp->capacity = newcapacity;
    78. 	}
    79. 	hp->a[hp->size] = x;
    80. 	hp->size++;
    81.  
    82. 	AdjustUp(hp->a, hp->size - 1);
    83. }
    84.  
    85. //向下调整（大堆或者小堆）
    86. void AdjustDown(HPDataType* a, int n, int parent)
    87. {
    88. 	int child = parent * 2 + 1;
    89. 	while (child < n)
    90. 	{
    91. 		//小堆
    92. 		if (child + 1 < n && a[child+1] < a[child])   //找到两个孩子节点较小的值
    93. 		{
    94. 			child++;
    95. 		}
    96. 		//建小堆
    97. 		if (a[child]<a[parent])
    98. 		{
    99. 			Swap(&a[child], &a[parent]);
    100. 			parent = child;
    101. 			child = parent * 2 + 1;
    102. 		}
    103. 		else
    104. 		{
    105. 			break;
    106. 		}
    107. 	}
    108. }
    109.  
    110.  
    111. // 堆顶元素的删除
    112. void HeapPop(Heap* hp)
    113. {
    114. 	assert(hp);
    115. 	assert(hp->size>0);
    116.  
    117. 	Swap(&hp->a[0], &hp->a[hp->size-1]);
    118. 	--hp->size;
    119. 	AdjustDown(hp->a, hp->size, 0); //大堆
    120. }
    121.  
    122. // 堆的构建
    123. void HeapCreate(Heap* hp, HPDataType* a, int n)
    124. {
    125. 	assert(hp);
    126. 	assert(a);
    127. 	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    128. 	if (hp->a == NULL)
    129. 	{
    130. 		perror("malloc fail");
    131. 		exit(-1);
    132. 	}
    133. 	hp->size = n;
    134. 	hp->capacity = n;
    135. 	memcpy(hp->a, a,sizeof(HPDataType) * n);
    136.  
    137. 	//建堆
    138. 	for (int i = 1; i < n; i++)
    139. 	{
    140. 		AdjustUp(hp->a, i);
    141. 	}
    142. }
    143.  
    144. // 取堆顶的数据
    145. HPDataType HeapTop(Heap* hp)
    146. {
    147. 	assert(hp);
    148. 	assert(hp->size > 0);
    149. 	return hp->a[0];
    150. }
    151.  
    152. // 堆的判空
    153. int HeapEmpty(Heap* hp)
    154. {
    155. 	assert(hp);
    156. 	return hp->size == 0;
    157. }
    158.  
    159. // 堆的数据个数
    160. int HeapSize(Heap* hp)
    161. {
    162. 	assert(hp);
    163. 	return hp->size;
    164. }

    2.3、堆的插入

    堆是一个完全二叉树，在插入元素时是在堆的末尾插入的，但是为了把一个元素插入后，使这个堆还是一个堆，我们需要对堆中的数据尽心再次调整。

    向上调整

    我们插入一个元素是，在进行向上调整，把这个数放到合适的位置。我们来看看代码实现

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

    下面这张图帮助大家理解

    接下来我们来实现堆的插入

    我们还是和顺序表一样，相对其扩容情况进行讨论，当hp->size==hp->capacity时，证明没有多余空间了，我们需要增加空间，这里还是使用，realloc函数，将这个数插入进去后，对这个数进行向上调整，使之变成一个新堆。

    1. void HeapPush(Heap* hp, HPDataType x)
    2. {
    3. 	assert(hp);
    4. 	if (hp->size == hp->capacity)
    5. 	{
    6. 		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
    7. 		HPDataType* tem = (HPDataType*)realloc(hp->a,sizeof(HPDataType)*newcapacity);
    8. 		if (tem == NULL)
    9. 		{
    10. 			perror("malloc fail");
    11. 			exit(-1);
    12. 		}
    13. 		hp->a = tem;
    14. 		hp->capacity = newcapacity;
    15. 	}
    16. 	hp->a[hp->size] = x;
    17. 	hp->size++;
    18.  
    19. 	AdjustUp(hp->a, hp->size - 1);
    20. }

    2.4、堆的删除

    向上调整

    我们在堆中删除一个元素时删除的时堆顶元素，也就是第一个元素，我们一般会先让第一个元素和最后一个元素交换位置，然后hp->size--；为了让新的数据成为堆，我们将第一个数据向下调整，使之变成一个新堆。

    我们来看看向下调整的代码该如何写：

    1. void AdjustDown(HPDataType* a, int n, int parent)
    2. {
    3. 	int child = parent * 2 + 1;
    4. 	while (child < n)
    5. 	{
    6. 		//小堆
    7. 		if (child + 1 < n && a[child+1] > a[child])   //找到两个孩子节点较大的值
    8. 		{
    9. 			child++;
    10. 		}
    11. 		//建小堆
    12. 		if (a[child]>a[parent])
    13. 		{
    14. 			Swap(&a[child], &a[parent]);
    15. 			parent = child;
    16. 			child = parent * 2 + 1;
    17. 		}
    18. 		else
    19. 		{
    20. 			break;
    21. 		}
    22. 	}
    23. }

    我们来看看这张图跟好的理解向下调整：

    接下来我们来实现堆的删除

    我们先考虑一下hp->size的临界问题，用一个断言就可以避免此类问题。

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

    三、建堆

    给一个数组我们如何把这个数组建成堆呢？

    一般我们都有两种方法：

    3.1、自顶向下（向上调整）

    我们来看看代码如何实现

    1. void HeapCreate(Heap* hp, HPDataType* a, int n)
    2. {
    3. 	assert(hp);
    4. 	assert(a);
    5. 	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    6. 	if (hp->a == NULL)
    7. 	{
    8. 		perror("malloc fail");
    9. 		exit(-1);
    10. 	}
    11. 	hp->size = n;
    12. 	hp->capacity = n;
    13. 	memcpy(hp->a, a,sizeof(HPDataType) * n);
    14.  
    15. 	//建堆
    16. 	for (int i = 1; i < n; i++)
    17. 	{
    18. 		AdjustUp(hp->a, i);
    19. 	}
    20. }

    我们使用错位相减的方式来计算 自顶向下（向上调整）的时间复杂度

    时间复杂度：O（nlog(2)^n)

    3.2、自低向上（向下调整）

    我们来看看代码如何实现

    1. void HeapCreate(Heap* hp, HPDataType* a, int n)
    2. {
    3. 	assert(hp);
    4. 	assert(a);
    5. 	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    6. 	if (hp->a == NULL)
    7. 	{
    8. 		perror("malloc fail");
    9. 		exit(-1);
    10. 	}
    11. 	hp->size = n;
    12. 	hp->capacity = n;
    13. 	memcpy(hp->a, a,sizeof(HPDataType) * n);
    14.  
    15. 	//建堆
    16.     //向下调整算法
    17. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    18. 	{
    19. 		AdjustDown(arr, n, i);
    20. 	}
    21. }
    22.

    和自顶向下一样，还是错位相减来计算时间复杂度

    时间复杂度：O（n）

    四、堆的排序

    我们学习堆，有一个很有用的地方，就是可以用堆进行排序，因为我们知道，大堆堆顶元素是数组中最小的，小队堆顶是数组中元素最小的。

    当我们需要将一个数组进行从小到大的排序时：

    1.将该数组建成一个大堆

    2.第一个数和最后一个数交换，然后把交换的那个较大的数不看做堆里面

    3.前n-1和数进行向下调整算法，选出大的数放到根节点，再跟倒数第二个交换......

     代码如下：

    1. void HeapSort(int* a,int n)
    2. {
    3. 	int i = 0;
    4. 	//这里用向下调整算法来建堆,因为时间复杂度只有O(N)
    5. 	for (i = (n - 1 - 1) / 2; i >= 0; i--)
    6. 	{
    7. 		AdjustDown(a, n, i);
    8. 	}
    9. 	int end = n - 1;
    10. 	while (end > 0)
    11. 	{
    12. 		Swap(&amp;a[0], &amp;a[end]);
    13. 		AdjustUp(a, end, 0);
    14. 		--end;
    15. 	}
    16. }

    时间复杂度：O（Nlog(2)^N）

    五、topk问题

    我们在做一些编程题会遇到一类问题，就是topk问题

    topk问题指的有一组很大的数据，我们需要返回它最大（最小）的前K个元素。

    这里我们就可以用堆排序很好的解决此类问题。

    这里力扣平台有一个练习题，我们一起来看一看

    面试题 17.14. 最小K个数 - 力扣（LeetCode）

    思路：我们先建立一个大堆，先把前K个元素建成一个大堆，然后在将剩下的数和堆顶元素进行比较，如过大于堆顶数据，我们就和堆顶元素进行交换，然后将现在的堆顶元素向下调整，前k个数就是这组数据中最小的前K个数。

    我们来看看该如何实现：

    1. void Swap(int* p1, int* p2)
    2. {
    3. 	int temp = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = temp;
    6. }
    7. //向下调整
    8. void AdjustDown(int* a, int n, int parent)
    9. {
    10. 	int child = parent * 2 + 1;
    11. 	while (child < n)
    12. 	{
    13. 		//大堆
    14. 		if (child + 1 < n && a[child+1] > a[child])   //找到两个孩子节点较小的值
    15. 		{
    16. 			child++;
    17. 		}
    18. 		//建大堆
    19. 		if (a[child]>a[parent])
    20. 		{
    21. 			Swap(&a[child], &a[parent]);
    22. 			parent = child;
    23. 			child = parent * 2 + 1;
    24. 		}
    25. 		else
    26. 		{
    27. 			break;
    28. 		}
    29. 	}
    30. }
    31.  
    32. int* smallestK(int* arr, int arrSize, int k, int* returnSize)
    33. {
    34.     if(k==0)
    35.     {
    36.         *returnSize=0;
    37.         return NULL;
    38.     }
    39.     int *ret=(int*)malloc(sizeof(int)*k);
    40.     for(int i=0;i<k;i++)
    41.     {
    42.         ret[i]=arr[i];
    43.     }
    44.  
    45.  
    46.     //给前k个元素建大堆
    47.     for(int i=(k-1-1)/2;i>=0;i--)
    48.     {
    49.         AdjustDown(ret, k, i);
    50.     }
    51.  
    52.     for(int i=k;i<arrSize;i++)
    53.     {
    54.         if(ret[0]>arr[i])
    55.         {
    56.             ret[0]=arr[i];
    57.             AdjustDown(ret,k,0);
    58.         }
    59.     }
    60.     *returnSize=k;
    61.     return ret;
    62. }

    六、大量数据中的topk问题

    比如我们现在有100000个数据，我们要找到最大的10个数据，我们需要改怎么实现，还是利用topk解决，我们先将前100个数据建成一个小堆

    1. //创建一个文件，并且随机生成一些数字
    2. void CreateDataFile(const char* filename, int N)
    3. {
    4. 	FILE* Fin = fopen(filename, "w");
    5. 	if (Fin == NULL)
    6. 	{
    7. 		perror("fopen fail");
    8. 		exit(-1);
    9. 	}
    10. 	srand(time(0));
    11. 	for (int i = 0; i < N; i++)
    12. 	{
    13. 		fprintf(Fin, "%d ", rand() % 10000);
    14. 	}
    15. }
    16. void PrintTopK(const char* filename, int k)
    17. {
    18. 	assert(filename);
    19. 	FILE* fout = fopen(filename, "r");
    20. 	if (fout == NULL)
    21. 	{
    22. 		perror("fopen fail");
    23. 		return;
    24. 	}
    25. 	int* minheap = (int*)malloc(sizeof(int) * k);
    26. 	if (minheap == NULL)
    27. 	{
    28. 		perror("malloc fail");
    29. 		return;
    30. 	}
    31. 	//读前k个数
    32. 	for (int i = 0; i < k; i++)
    33. 	{
    34. 		//空格和换行默认是多个值之间的间隔
    35. 		fscanf(fout, "%d", &amp;minheap[i]);
    36. 	}
    37. 	//建k个数的堆
    38. 	for (int j = (k - 1 - 1) / 2; j >= 0; j--)
    39. 	{
    40. 		AdjustDown(minheap, j, k, cmp_down);
    41. 	}
    42. 	//读取后N-K个
    43. 	int x = 0;
    44. 	while(fscanf(fout,"%d",&amp;x)!=EOF)
    45. 	{
    46. 		if (x > minheap[0])
    47. 		{
    48. 			minheap[0] = x;
    49. 			AdjustDown(minheap, 0, k, cmp_down);
    50. 		}
    51. 	}
    52. 	for (int i = 0; i < k; i++)
    53. 	{
    54. 		printf("%d ", minheap[i]);
    55. 	}
    56. 	printf("\n");
    57. 	free(minheap);
    58. 	fclose(fout);
    59. }
    60. int main()
    61. {
    62. 	//CreateDataFile("data.txt", 1000000);
    63. 	//找前10个最大的数
    64. 	PrintTopK("data.txt", 10);
    65. 	return 0;
    66. }

    这里只截取了一小部分

    我们提前改10个较大的数，验证返回的正确错误。

    返回的就是我们改的10个大的数字，证明返回正确，而且效率极其的高！

    总结：堆的知识就介绍到这里，如有疑问或者质疑，请在评论区发出来，我会尽全力帮大家解决，成长的路上少不了你们的支持，你们的三连是我进步最大的动力，还望大佬们多多支持，一起加油！共勉！

  • 相关阅读:
    vue3【计算属性与监听-详】
    Linux 和 Window 软件包管理器
    四旋翼飞行器基本模型（Matlab&Simulink）
    vue3使用富文本编辑器wangEditor-v5（未使用composition api写法）
    Python机器学习、深度学习提升气象、海洋、水文领域实践应用
    C语言定制shell命令
    【微信公众号开发】1.1 微信公众号开发课程内容介绍
    CentOS常用基础命令汇总
    前端构建工具用得好，构建速度提升 10 倍
    Shell脚本编程实践——第1关：编写一个脚本，求斐波那契数列的前10项及总和
  • 原文地址：https://blog.csdn.net/m0_69323023/article/details/132834448