• 堆结构的深度理解

    目录

    一、堆的概念及其结构

    二、堆的实现

    2.1 向上调整算法

    2.2 向下调整算法

    2.3 堆的插入

    2.4 堆的删除

    2.5 完整实现代码

    三、堆排序

    3.1 建堆

    解决方案一

    解决方案二

    3.2 建堆时间复杂度分析

    方案一分析

    方案二分析

    3.3 实现排序

    3.4 完整代码实现

    四、TOP-K问题

    思路

    本文将详细讲解数据结构中的堆，并非是计算机存储概念上的堆区

    一、堆的概念及其结构

    概念:

    如果有一个关键码的集合K = {K0，K1， K2，…，Kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i + 1 且 Ki <= K2i + 2 ，则称为小堆(或大堆)

    将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆

    性质:
    1. 堆中某个节点的值总是不大于或不小于其父节点的值；
    2. 堆逻辑结构是一棵完全二叉树，其物理结构为数组

    二、堆的实现

    2.1 向上调整算法

    以小堆为例进行讲解

    1. void AdjustUp(HPDataType* array,int child)
    2. {
    3. 	int parent = (child - 1) / 2;
    4. 	while (array[child] < array[parent] && child)
    5. 	{
    6. 		Swap(&array[child], &array[parent]);
    7. 		child = parent;
    8. 		parent = (child - 1) / 2;
    9. 	}
    10. }

    2.2 向下调整算法

    向下调整算法有一个前提：左右子树必须是堆，才能调整

    以小堆为例进行讲解

    1. void AdjustDown(HPDataType* array, int size, int parent)
    2. {
    3. 	int child = parent * 2 + 1;
    4. 	while (child < size) {
    5. 		if (child + 1 < size && array[child + 1] > array[child]) ++child;
    6. 		if (array[child] > array[parent]) {
    7. 			Swap(&array[child], &array[parent]);
    8. 			parent = child;
    9. 			child = parent * 2 + 1;
    10. 		}
    11. 		else {
    12.             break;
    13.         }
    14. 	}
    15. }

    2.3 堆的插入

    先插入数据到数组的尾部，再对插入元素进行向上调整算法，使得插入元素出现在该出现的位置，满足堆的所有性质

    1. void HeapPush(Heap* hp,HPDataType x)
    2. {
    3. 	assert(hp);
    4. 	if (hp->_size == hp->_capacity) {
    5. 		int newCapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
    6. 		HPDataType* temp = (HPDataType*)realloc(hp->_data, sizeof(HPDataType) * newCapacity);
    7. 		if (temp == NULL) {
    8. 			perror("realloc fail:");
    9. 			exit(-1);
    10. 		}
    11. 		hp->_data = temp;
    12. 	}
    13. 	hp->_data[hp->_size] = x;
    14. 	++hp->_size;
    15. 	AdjustUp(hp->_data, hp->_size - 1);
    16. }

    2.4 堆的删除

    删除堆是删除堆顶的数据，将堆顶的数据与最后一个数据交换。再删除数组最后一个数据，最后对堆顶元素进行向下调整算法。

    1. void HeapPop(Heap* hp)//删除堆顶数据
    2. {
    3. 	assert(hp);
    4. 	Swap(&(hp->_data[0]), &(hp->_data[hp->_size - 1]));
    5. 	--hp->_size;
    6. 	AdjustDown(hp->_data, hp->_size, 0);
    7. }

    2.5 完整实现代码

    1. #include
    2. #include
    3. #include
    4. #include
    5. typedef int HPDataType;
    6. typedef struct Heap {
    7. 	HPDataType* _data;
    8. 	int _capacity;
    9. 	int _size;
    10. }Heap;
    11.  
    12. void HeapInit(Heap* hp) 
    13. {
    14. 	assert(hp);
    15. 	hp->_data = NULL;
    16. 	hp->_capacity = hp->_size = 0;
    17. }
    18. void HeapDestory(Heap* hp)
    19. {
    20. 	assert(hp);
    21. 	free(hp->_data);
    22. 	hp->_capacity = hp->_size = 0;
    23. }
    24.  
    25. void Swap(HPDataType* x, HPDataType* y)
    26. {
    27. 	HPDataType temp = *x;
    28. 	*x = *y;
    29. 	*y = temp;
    30. }
    31.  
    32. void AdjustUp(HPDataType* array,int child)
    33. {
    34. 	int parent = (child - 1) / 2;
    35. 	while (array[child] < array[parent] && child)
    36. 	{
    37. 		Swap(&array[child], &array[parent]);
    38. 		child = parent;
    39. 		parent = (child - 1) / 2;
    40. 	}
    41. }
    42. void HeapPush(Heap* hp,HPDataType x)
    43. {
    44. 	assert(hp);
    45. 	if (hp->_size == hp->_capacity) {
    46. 		int newCapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
    47. 		HPDataType* temp = (HPDataType*)realloc(hp->_data, sizeof(HPDataType) * newCapacity);
    48. 		if (temp == NULL) {
    49. 			perror("realloc fail:");
    50. 			exit(-1);
    51. 		}
    52. 		hp->_data = temp;
    53. 	}
    54. 	hp->_data[hp->_size] = x;
    55. 	++hp->_size;
    56. 	AdjustUp(hp->_data, hp->_size - 1);
    57. }
    58.  
    59. void AdjustDown(HPDataType* array, int size, int parent)
    60. {
    61. 	int child = parent * 2 + 1;
    62. 	while (child < size){
    63. 		if (child + 1 < size && array[child + 1] > array[child]) ++child;
    64. 		if (array[child] > array[parent]) {
    65. 			Swap(&array[child], &array[parent]);
    66. 			parent = child;
    67. 			child = parent * 2 + 1;
    68. 		}
    69. 		else break;
    70. 	}
    71. }
    72. void HeapPop(Heap* hp)//删除堆顶数据
    73. {
    74. 	assert(hp);
    75. 	Swap(&(hp->_data[0]), &(hp->_data[hp->_size - 1]));
    76. 	--hp->_size;
    77. 	AdjustDown(hp->_data, hp->_size, 0);
    78. }
    79.  
    80. HPDataType HeapTop(Heap* hp) 
    81. {
    82. 	assert(hp);
    83. 	assert(hp->_size > 0);
    84. 	return (hp->_data[0]);
    85. }
    86. bool HeapIsEmpty(Heap* hp)
    87. {
    88. 	assert(hp);
    89. 	return hp->_size == 0;
    90. }
    91. int HeapSize(Heap* hp)
    92. {
    93. 	assert(hp);
    94. 	return hp->_size;
    95. }

    三、堆排序

    3.1 建堆

    若要排升序，则要建大堆；若要排降序，则要建小堆

    建堆问题有两种解决方案，其中解决方案二更好

    解决方案一

    利用堆插入的思想，尾部每多一个元素则进行一次向上调整

    1. for (int i = 1; i < size; ++i) {
    2. 	AdjustUp(array, i);
    3. }

    解决方案二

    向下调整算法的前提为左右子树必须是堆才可以进行调整。

    若想建堆，可以从倒数的第一个非叶子节点的子树开始调整(使用向下调整算法)，一直调整到根节点，就可以将整棵调整成堆

    1. for (int i = (size - 1 - 1) / 2; i >= 0; --i) {//叶子不需要调整
    2. 		AdjustDown(array, size, i);
    3. }

    3.2 建堆时间复杂度分析

    堆是完全二叉树，而满二叉树也是特殊的完全二叉树，此处为了简化使用满二叉树来证明

    (时间复杂度本身就是分析近似值的，稍多几个节点并不影响最终结果)

    方案一分析

     由上可知，方案一的时间复杂度为O(NlogN)

    方案二分析

     由上可知，方案二的时间复杂度为O(N)

    3.3 实现排序

    利用删除的思想，每次"删除"堆顶的元素(若为小堆即最小值，若为大堆即最大值)

    但并非真正删除，而是在逻辑中的堆进行删除，放在堆的最后一个位置，下次计算时不再将该元素视为在堆中。

    1. for (int i = size- 1; i > 0; --i)//删除的思想，每次删除的都是堆中最小的数
    2. {
    3. 	Swap(&array[0], &array[i]);
    4. 	AdjustDown(array, i, 0);
    5. }

    3.4 完整代码实现

    1. #include
    2. typedef int HPDataType;
    3. void Swap(HPDataType* x, HPDataType* y)
    4. {
    5. 	HPDataType temp = *x;
    6. 	*x = *y;
    7. 	*y = temp;
    8. }
    9. void AdjustDown(HPDataType* array, int size, int parent)
    10. {
    11. 	int child = parent * 2 + 1;
    12. 	while (child < size) {
    13. 		if (child + 1 < size && array[child + 1] > array[child]) ++child;
    14. 		if (array[child] > array[parent]) {
    15. 			Swap(&array[child], &array[parent]);
    16. 			parent = child;
    17. 			child = parent * 2 + 1;
    18. 		}
    19. 		else break;
    20. 	}
    21. }
    22. void HeapSort(int* array,int size) 
    23. {
    24. 	for (int i = size/2 - 1; i >= 0; --i) {//叶子不需要调整
    25. 		AdjustDown(array, size, i);
    26. 	}
    27. 	for (int i = size- 1; i > 0; --i)//删除的思想，每次删除的都是堆中最小的数
    28. 	{
    29. 		Swap(&array[0], &array[i]);
    30. 		AdjustDown(array, i, 0);
    31. 	}
    32. }
    33. int main()
    34. {
    35. 	int array[] = { 27,15,19,18,28,34,65,49,25,37 };
    36. 	HeapSort(array, sizeof(array) / sizeof(array[0]));
    37. 	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i) {
    38. 		printf("%d ", array[i]);
    39. 	}
    40. 	return 0;
    41. }

    四、TOP-K问题

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

    对于Top-K问题，能想到的最简单直接的方式就是排序

    但是若数据量非常大，排序就不太可取了(因为内存大小有限，数据不能一下全部加载到内存中)

    最佳的方式就是用堆来解决

    思路

    1.用数据集合中前K个元素来建堆
            若求前k个最大的元素，则建小堆
            若求前k个最小的元素，则建大堆

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

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

    1. #include
    2. #include
    3. #include
    4. typedef int HPDataType;
    5. void Swap(HPDataType* x, HPDataType* y)
    6. {
    7. 	HPDataType temp = *x;
    8. 	*x = *y;
    9. 	*y = temp;
    10. }
    11. void AdjustDown(HPDataType* array, int size, int parent)
    12. {
    13. 	int child = parent * 2 + 1;
    14. 	while (child < size) {
    15. 		if (child + 1 < size && array[child + 1] > array[child]) ++child;
    16. 		if (array[child] > array[parent]) {
    17. 			Swap(&array[child], &array[parent]);
    18. 			parent = child;
    19. 			child = parent * 2 + 1;
    20. 		}
    21. 		else break;
    22. 	}
    23. }
    24. void PrintTopK(int* array, int n, int k)
    25. {
    26. 	int* MinHeap = (int*)malloc(sizeof(int) * k);
    27. 	if (MinHeap == NULL) {
    28. 		perror("malloc fail:");
    29. 		exit(-1);
    30. 	}
    31.  
    32. 	for (int i = 0; i < k; ++i) {//取前k个数据
    33. 		MinHeap[i] = array[i];
    34. 	}
    35.  
    36. 	for (int i = (k - 1 - 1) / 2; i >= 0; --i) {//建堆
    37. 		AdjustDown(MinHeap, k, i);
    38. 	}
    39. 	for (int i = k; i < n; ++i) {//用剩余的N-K个元素依次与堆顶元素来比较
    40. 		if (array[i] > MinHeap[0]) {
    41. 			Swap(&array[i], &MinHeap[0]);
    42. 			AdjustDown(MinHeap, k, 0);
    43. 		}
    44. 	}
    45.  
    46. 	for (int i = 0; i < k; ++i) {//输出
    47. 		printf("%d ", MinHeap[i]);
    48. 	}
    49. 	printf("\n");
    50. }
    51. int main()
    52. {
    53. 	int n = 10000;
    54. 	int* array = (int*)malloc(sizeof(int) * n);
    55. 	if (array == NULL) {
    56. 		perror("malloc fail:");
    57. 		exit(-1);
    58. 	}
    59.  
    60. 	srand((unsigned)time(NULL));
    61. 	for (size_t i = 0; i < n; ++i)
    62. 	{
    63. 		array[i] = rand() % 1000000;
    64. 	}
    65.  
    66. 	array[5] = 1000000 + 1;
    67. 	array[1231] = 1000000 + 2;
    68. 	array[531] = 1000000 + 3;
    69. 	array[5121] = 1000000 + 4;
    70. 	array[115] = 1000000 + 5;
    71. 	array[2335] = 1000000 + 6;
    72. 	array[9999] = 1000000 + 7;
    73. 	array[76] = 1000000 + 8;
    74. 	array[423] = 1000000 + 9;
    75. 	array[3144] = 1000000 + 10;
    76.  
    77. 	PrintTopK(array, n, 10);//k == 10
    78. 	return 0;
    79. }
    80.

  • 相关阅读:
    docker删除none镜像
    VMware各版本镜像下载站
    SaaSBase：什么是SaleSmartly？
    红细胞膜载近红外荧光染料IR780的壳膜/细胞膜荧光染料CM-Dil标记BMSCs的制备
    【Java SE】继承
    深度学习-个人自用
    数据库数据恢复-SQL SERVER数据库文件损坏的故障表现&数据恢复方案
    高薪程序员&面试题精讲系列148之你熟悉哪些加密算法(下篇)？如何保证项目的安全性?
    不同深度的埋点事件如何微妙地改变广告系列的成本
    Docker镜像详解（手拉手教你上传至阿里云，发布到私有库）
  • 原文地址：https://blog.csdn.net/GG_Bruse/article/details/127742947