devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

揭秘数据结构的魔力：用堆（Heap）打造高效排序

作者：羊村懒王 | 2024-06-06 15:22:24

赞

踩

揭秘数据结构的魔力：用堆（Heap）打造高效排序

个人主页：一代... 

个人专栏：数据结构

1. 定义：

  • 堆通常是一个可以被看做一棵树的数组对象，在物理层面上表现为顺序存储结构，但在逻辑层面上是完全二叉树的形态，这意味着除了最后一层外，每一层都被完全填满，且最后一层从左到右填充。
  • 堆中某个结点的值总是不大于或不小于其父结点的值，这一性质使得堆成为最高效的优先级队列。

（注意：大堆和小堆的实现都是用数组来实现的，其物理结构是数组 但其逻辑结构是一颗完全二叉树）

用数组实现堆，假设其双亲节点的下标为i，则其左孩子节点的下标为2*i+1，右孩子节点的下标为2*i+2

若孩子节点的坐标为i（这里的孩子节点无论是左孩子还是右孩子），其双亲节点的坐标都为(i-1)/2;

如果想要一个数组变为堆，首先要把其看做完全二叉树的结构

如数组a[4]={2,1,3,4}

将其理解为树的结构就变为：（理解为树的结构后就可以对其进行操作，将其变为大堆或小堆）

2. 堆的分类

堆分为大堆和小堆

  1. 大堆：大堆的双亲节点都大于其孩子节点

  1. 小堆：小堆的双亲节点都小于其孩子节点

3. 堆的实现

a. 堆的结构体定义:

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

b. 堆的初始化

  1. void HPInit(HP* php)
  2. {
  3. 	php->a = NULL;
  4. 	php->capacity = php->size = 0;
  5. }

c. 堆的建立

ⅰ. 向上调整法

向上调整法要从第一个元素开始，向上调整法建小堆时，当孩子节点小于双亲节点时，孩子节点的值就和父亲节点的值交换，孩子节点坐标等于双亲节点的坐标，双亲节点的坐标变为（双亲节点的坐标-1）/ 2，当孩子节点==0时循环结束。

  1. void Swap(HPDataType* a, HPDataType* b)
  2. {
  3. 	HPDataType tmp = *a;
  4. 	*a = *b;
  5. 	*b = tmp;
  6. }
  7.  
  8. void AdjustUp(HPDataType* a, int child)
  9. //不传结构体，为了后面排序做准备，原因后面会解释
  10. {
  11. 	assert(a);
  12. 	int parent = (child - 1) / 2;
  13. 	while (child > 0)
  14. 		//parent>=0可以作为结束条件，但是一个巧合，
  15. 		//因为到最后是依靠当child==0，parent=（child-1）/2=-1/2=0时
  16. 		//a[parent]==a[child]结束的
  17. 	{
  18. 		if (a[child] < a[parent])//建小堆，若a[child]>a[parent]就建大堆
  19. 		{
  20. 			Swap(&a[child], &a[parent]);
  21. 			child = parent;
  22. 			parent = (parent - 1) / 2;
  23. 		}
  24. 		else
  25. 		{
  26. 			break;
  27. 		}
  28. 	}
  29. }
1. 向上调整法建堆
  1. void Swap(HPDataType* a, HPDataType* b)
  2. {
  3. 	HPDataType tmp = *a;
  4. 	*a = *b;
  5. 	*b = tmp;
  6. }
  7.  
  8. void AdjustUp(HPDataType* a, int child)
  9. //不传结构体，为了后面排序做准备，原因后面会解释
  10. {
  11. 	assert(a);
  12. 	int parent = (child - 1) / 2;
  13. 	while (child > 0)
  14. 		//parent>=0可以作为结束条件，但是一个巧合，
  15. 		//因为到最后是依靠当child==0，parent=（child-1）/2=-1/2=0时
  16. 		//a[parent]==a[child]结束的
  17. 	{
  18. 		if (a[child] < a[parent])//建小堆，若a[child]>a[parent]就建大堆
  19. 		{
  20. 			Swap(&a[child], &a[parent]);
  21. 			child = parent;
  22. 			parent = (parent - 1) / 2;
  23. 		}
  24. 		else
  25. 		{
  26. 			break;
  27. 		}
  28. 	}
  29. }
  30.  
  31. void HPInitArray(HP* php, HPDataType* a, int n)
  32. {
  33. 	assert(php);
  34. 	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
  35. 	if (php->a == NULL)
  36. 	{
  37. 		perror("malloc fail!");
  38. 		return;
  39. 	}
  40. 	memcpy(php->a, a, n * sizeof(HPDataType));
  41. 	php->capacity = php->size = n;
  42. 	//向上调整
  43. 	for (int i = 1; i < n; i++)//这里遍历要从下标为1的元素开始，即从第一个孩子节点开始
  44. 	{
  45. 		AdjustUp(php->a, i);
  46. 	}
  47. }
  48.  
  49. int main()
  50. {
  51. 	HPDataType a[] = { 50,100,480,76,31,31,226 };
  52. 	HPSort(a, sizeof(a) / sizeof(a[0]));//之前向上调整和向下调整就是为了这里
  53. 	//直接传a数组，而不是
  54. 	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  55. 	{
  56. 		printf("%d ", a[i]);//排升序
  57. 	}
  58. 	HP hp;
  59. 	HPInit(&hp);
  60.     HPInitArray(&hp,a,sizeof(a)/sizeof(HPDataType));
  61.     
  62. 	return 0;
  63. }

2. 向上调整法建堆的时间复杂度

所以向上调整建堆的时间复杂度为O(N*logN)，向上调整法的时间复杂度为O(logN)（即调整高度次）

ⅱ. 向下调整法

转换之后就变为小堆

向下调整法时要从最后一个元素的双亲节点开始，在向下调整建小堆的过程中，用假设法选出左右孩子中最小的一个，当孩子节点大于双亲节点时，孩子节点就和双亲节点交换，双亲节点等于孩子节点，孩子节点等于双亲节点*2+1（不可以为双亲节点*2+2，必须为有孩子·，以便后面比较左右孩子的大小），当孩子节点的坐标大于等于总数组的大小时，就跳出循环

  1. void Swap(HPDataType* a, HPDataType* b)
  2. {
  3. 	HPDataType tmp = *a;
  4. 	*a = *b;
  5. 	*b = tmp;
  6. }
  7.  
  8. void AdjustDown(HPDataType* a, int n, int parent)
  9. //不传结构体，为了后面排序做准备，原因后面会解释
  10. {
  11. 	assert(a);
  12. 	int child = parent * 2 + 1;
  13. 	while (child < n)
  14. 	{
  15. 		//假设法
  16. 		if (child + 1 < n && a[child] < a[child + 1])
  17. 		{
  18. 			child++;
  19. 		}
  20. 		if (a[parent] < a[child])
  21. 		{
  22. 			Swap(&a[parent], &a[child]);
  23. 			parent = child;
  24. 			child = parent * 2 + 1;//右孩子，不可以为左孩子，因为上面要比较
  25. 		}
  26. 		else
  27. 		{
  28. 			break;
  29. 		}
  30. 	}
  31. }
1. 向下调整法建堆
  1. void Swap(HPDataType* a, HPDataType* b)
  2. {
  3. 	HPDataType tmp = *a;
  4. 	*a = *b;
  5. 	*b = tmp;
  6. }
  7.  
  8. void AdjustDown(HPDataType* a, int n, int parent)
  9. //不传结构体，为了后面排序做准备，原因后面会解释
  10. {
  11. 	assert(a);
  12. 	int child = parent * 2 + 1;
  13. 	while (child < n)
  14. 	{
  15. 		//假设法
  16. 		if (child + 1 < n && a[child] < a[child + 1])
  17. 		{
  18. 			child++;
  19. 		}
  20. 		if (a[parent] < a[child])//建大堆
  21. 		{
  22. 			Swap(&a[parent], &a[child]);
  23. 			parent = child;
  24. 			child = parent * 2 + 1;//右孩子，不可以为左孩子，因为上面要比较
  25. 		}
  26. 		else
  27. 		{
  28. 			break;
  29. 		}
  30. 	}
  31. }
  32.  
  33. void HPInitArray(HP* php, HPDataType* a, int n)
  34. {
  35. 	assert(php);
  36. 	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
  37. 	if (php->a == NULL)
  38. 	{
  39. 		perror("malloc fail!");
  40. 		return;
  41. 	}
  42. 	memcpy(php->a, a, n * sizeof(HPDataType));
  43. 	php->capacity = php->size = n;
  44. 	//向下调整
  45. 	for (int i = (php->size - 1 - 1) / 2; i >= 0; i--)
  46. 	//数组的大小为size,对应下标为size-1,其数组最后一个元素
  47. 	//的双亲为(size-1-1)/2;
  48. 	{
  49. 		AdjustDown(php->a, n, i);
  50. 	}
  51. }
  52.  
  53. int main()
  54. {
  55. 	HPDataType a[] = { 50,100,480,76,31,31,226 };
  56. 	HPSort(a, sizeof(a) / sizeof(a[0]));//之前向上调整和向下调整就是为了这里
  57. 	//直接传a数组，而不是
  58. 	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  59. 	{
  60. 		printf("%d ", a[i]);//排升序
  61. 	}
  62. 	HP hp;
  63. 	HPInit(&hp);
  64.     HPInitArray(&hp,a,sizeof(a)/sizeof(HPDataType));
  65.     
  66. 	return 0;
  67. }

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

所以向下调整法建堆的时间复杂度为O(N)，向下调整法的时间复杂度为logN

d. 堆的插入

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

ⅰ. 时间复杂度

运用了一次向上调整法时间复杂度为O(logN)

e. 堆的删除

堆的删除要交换堆顶元素和最后一个元素，把size--，在用一次向下调整法就可以了，不可以直接删除堆顶元素再建堆，一来这样时间复杂度增大了，二是删除堆顶元素，元素之间关系错乱了，父子变叔侄，兄弟变父子

  1. void HPPop(HP* php)
  2. {
  3. 	assert(php);
  4. 	assert(php->size > 0);
  5.  
  6. 	Swap(&php->a[0], &php->a[php->size - 1]);
  7. 	php->size--;
  8.  
  9. 	AdjustDown(php->a, php->size, 0);
  10. }

ⅰ. 时间复杂度

运用了一次向下调整法，时间复杂度为O(logN)

f. 堆的判空

  1. bool HPEmpty(HP* php)
  2. {
  3. 	assert(php);
  4.  
  5. 	return php->size == 0;
  6. }

ⅰ. 时间复杂度

时间复杂度为O(1)

g. 取堆元素

  1. HPDataType HPTop(HP* php)
  2. {
  3. 	assert(php);
  4. 	return php->a[0];
  5. }

ⅰ. 时间复杂度

时间复杂度为O(1)

h. 堆的摧毁

  1. void HPDestroy(HP* php)
  2. {
  3. 	assert(php);
  4. 	free(php->a);
  5. 	php->a = NULL;
  6. 	php->size = php->capacity = 0;
  7. }

i. 堆的排序（堆的向上调整法和向下调整法不传结构体的原因）

  1. void HPSort(HPDataType* a, int n)
  2. {
  3. 	//这里不用建大堆选出最大数,建堆的时间复杂度为O(N)
  4. 	// 取出最大数后再N-1个数进行建堆，执行次数为N-1
  5. 	//n个数，执行次数为N+N-1+N-2.....+1;时间复杂度为O(N^2)
  6. 	//，和冒泡排序时间复杂度为一样，没有时间上的优势
  7. 	for(int i=(n-1-1)/2;i>=0;i--)
  8. 	{
  9. 		AdjustDown(a, n, i);
  10. 	}
  11. 	//对数组进行升序排列
  12. 	//需要建大堆
  13. 	//收尾交换
  14. 	//把最后一个值不放在堆中,建大堆选出最大数，将其放在最后
  15. 	int end = n-1;
  16. 	while (end > 0)
  17. 	{
  18. 		Swap(&a[end], &a[0]);
  19. 		AdjustDown(a, end, 0);
  20. 		end--;
  21. 	}
  22. }

原因：由于向上调整法和向下调整法传结构体每次都需要建一个堆，太耗费时间，但如果传数组，在用调整法时就不需要写一个堆的结构体，比如堆的排序

ⅰ. 时间复杂度

向下调整法建堆的时间复杂度为O(N)，排序的时间复杂度为和向上调整时间一样，计算方式一样，为O(NlogN)，总的时间复杂度为O(NlogN)。

习题：在很大的数据个数中找出最大的k个数，借用文件的形式实现

  1. #define  _CRT_SECURE_NO_WARNINGS 1
  2. #include<stdio.h>
  3. #include<assert.h>
  4. #include<time.h>
  5. #include<stdlib.h>
  6.  
  7. void Swap(int *a,int *b)
  8. {
  9. 	int tmp = *a;
  10. 	*a = *b;
  11. 	*b = tmp;
  12. }
  13.  
  14. void createNData()
  15. {					 
  16. 	srand((unsigned int)time(NULL));
  17. 	const char* file = "data.txt";//要打开的文件
  18. 	FILE* fin = fopen(file, "w");
  19. 	if (fin == NULL)
  20. 	{
  21. 		perror("fopen fail");
  22. 		return;
  23. 	}
  24. 	for (int i = 1; i <= 20; i++)
  25. 	{
  26. 		int x = rand() % 10000 + 1;
  27. 		fprintf(fin, "%d\n", x);
  28. 	}
  29. 	fclose(fin);
  30. }
  31.  
  32. void AdjustDown(int* a, int n, int parent)
  33. {
  34. 	int child = parent * 2 + 1;
  35. 	while (child < n)
  36. 	{
  37. 		if (child + 1 < n && a[child] > a[child + 1])
  38. 		{
  39. 			child++;
  40. 		}
  41. 		if (a[parent] > a[child])
  42. 		{
  43. 			Swap(&a[parent], &a[child]);
  44. 			parent = child;
  45. 			child = parent * 2 + 1;
  46. 		}
  47. 		else
  48. 		{
  49. 			break;
  50. 		}
  51. 	}
  52. }
  53.  
  54. void topk()
  55. {
  56. 	int k;
  57. 	int x;
  58. 	const char* file = "data.txt";//要打开的文件
  59. 	printf("要找出的最大数字的个数:>");
  60. 	scanf("%d", &k);
  61.  
  62. 	FILE* fout = fopen("data.txt", "r");
  63. 	if (fout == NULL)
  64. 	{
  65. 		perror("fopen fail");
  66. 		return;
  67. 	}
  68. 	int* minheap = (int*)malloc(sizeof(int) * k);
  69. 	if (minheap == NULL)
  70. 	{
  71. 		perror("malloc fail");
  72. 		return;
  73. 	}
  74. 	for (int i = (k - 1 - 1)/2 ; i >= 0; i--)
  75. 	{
  76. 		AdjustDown(minheap, k, i);
  77. 	}
  78. 	while (fscanf(fout, "%d", &x) != EOF)
  79. 	{
  80. 		if (x > minheap[0])
  81. 		{
  82. 			minheap[0] = x;
  83. 			AdjustDown(minheap, k, 0);
  84. 		}
  85. 	}
  86. 	for (int i = 0; i < k; i++)
  87. 	{
  88. 		printf("%d\n", minheap[i]);
  89. 	}
  90. 	fclose(fout);
  91. }
  92. int main()
  93. {
  94. 	createNData();
  95. 	topk();
  96. 	return 0;
  97. }

堆的实现全部代码

test.c

  1. #define  _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include"Heap.h"
  4.  
  5. int main()
  6. {
  7. 	HPDataType a[] = { 50,100,480,76,31,31,226 };
  8. 	HPSort(a, sizeof(a) / sizeof(a[0]));//之前向上调整和向下调整就是为了这里
  9. 	//直接传a数组，而不是
  10. 	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  11. 	{
  12. 		printf("%d ", a[i]);//排升序
  13. 	}
  14. 	HP hp;
  15. 	//HPInitArray(&hp,a,sizeof(a)/sizeof(HPDataType));
  16. 	//HPInit(&hp);
  17. 	//HPInitArray(&hp, a, sizeof(a) / sizeof(HPDataType));
  18.  
  19. 	//for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  20. 	//{
  21. 	//	HPPush(&hp, a[i]);
  22. 	//}
  23. 	//printf("%d", HPTop(&hp));
  24. 	//HPPop(&hp);
  25. 	//for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  26. 	//{
  27. 	//	printf("%d ", (&hp)->a[i]);
  28. 	//}
  29. 	return 0;
  30. }
  31.  
  32.

Heap.c

  1. #define  _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include"Heap.h"
  4.  
  5. void HPInit(HP* php)
  6. {
  7. 	php->a = NULL;
  8. 	php->capacity = php->size = 0;
  9. }
  10.  
  11.  
  12. void Swap(HPDataType* a, HPDataType* b)
  13. {
  14. 	HPDataType tmp = *a;
  15. 	*a = *b;
  16. 	*b = tmp;
  17. }
  18.  
  19. void AdjustUp(HPDataType* a, int child)
  20. //不传结构体，为了后面排序做准备，原因后面会解释
  21. {
  22. 	assert(a);
  23. 	int parent = (child - 1) / 2;
  24. 	while (child>0)
  25. 		//parent>=0可以作为结束条件，但是一个巧合，
  26. 		//因为到最后是依靠当child==0，parent=（child-1）/2=-1/2=0时
  27. 		//a[parent]==a[child]结束的
  28. 	{
  29. 		if (a[child] < a[parent])
  30. 		{
  31. 			Swap(&a[child], &a[parent]);
  32. 			child = parent;
  33. 			parent = (parent - 1) / 2;
  34. 		}
  35. 		else
  36. 		{
  37. 			break;
  38. 		}
  39. 	}
  40. }
  41.  
  42. void HPPush(HP* php, HPDataType x)
  43. {
  44. 	assert(php);
  45. 	if (php->size == php->capacity)
  46. 	{
  47. 		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
  48. 		HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * newcapacity);
  49. 		if (tmp == NULL)
  50. 		{
  51. 			perror("realloc fail!");
  52. 			return;
  53. 		}
  54. 		php->a = tmp;
  55. 		php->capacity = newcapacity;
  56. 	}
  57. 	php->a[php->size] = x;
  58. 	php->size++;
  59. 	AdjustUp(php->a, php->size - 1);
  60. }
  61.  
  62. HPDataType HPTop(HP* php)
  63. {
  64. 	assert(php);
  65. 	return php->a[0];
  66. }
  67.  
  68. void AdjustDown(HPDataType* a, int n, int parent)
  69. //不传结构体，为了后面排序做准备，原因后面会解释
  70. {
  71. 	assert(a);
  72. 	int child = parent * 2 + 1;
  73. 	while (child < n)
  74. 	{
  75. 		//假设法
  76. 		if (child + 1 < n && a[child] < a[child + 1])
  77. 		{
  78. 			child++;
  79. 		}
  80. 		if (a[parent] < a[child])
  81. 		{
  82. 			Swap(&a[parent], &a[child]);
  83. 			parent = child;
  84. 			child = parent * 2 + 1;//右孩子，不可以为左孩子，因为上面要比较
  85. 		}
  86. 		else
  87. 		{
  88. 			break;
  89. 		}
  90. 	}
  91. }
  92.  
  93. void HPInitArray(HP* php, HPDataType* a, int n)
  94. {
  95. 	assert(php);
  96. 	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
  97. 	if (php->a == NULL)
  98. 	{
  99. 		perror("malloc fail!");
  100. 		return;
  101. 	}
  102. 	memcpy(php->a, a, n * sizeof(HPDataType));
  103. 	php->capacity = php->size = n;
  104. 	//向上调整
  105. 	//for (int i = 1; i < n; i++)
  106. 	//{
  107. 	//	AdjustUp(php->a, i);
  108. 	//  HPPush(php, php->size)//不可以，因为调用函数
  109. 	// 时php->size在函数内还会增加
  110. 	//}
  111. 	//向下调整
  112. 	for (int i = (php->size - 1 - 1) / 2; i >= 0; i--)
  113. 	//数组的大小为size,对应下标为size-1,其数组最后一个元素
  114. 	//的双亲为(size-1-1)/2;
  115. 	{
  116. 		AdjustDown(php->a, n, i);
  117. 	}
  118. }
  119.  
  120. //时间复杂度为logN
  121. void HPPop(HP* php)
  122. {
  123. 	assert(php);
  124. 	assert(php->size > 0);
  125.  
  126. 	Swap(&php->a[0], &php->a[php->size - 1]);
  127. 	php->size--;
  128.  
  129. 	AdjustDown(php->a, php->size, 0);
  130. }
  131.  
  132. bool HPEmpty(HP* php)
  133. {
  134. 	assert(php);
  135.  
  136. 	return php->size == 0;
  137. }
  138.  
  139. void HPDestroy(HP* php)
  140. {
  141. 	assert(php);
  142. 	free(php->a);
  143. 	php->a = NULL;
  144. 	php->size = php->capacity = 0;
  145. }
  146.  
  147. void HPSort(HPDataType* a, int n)
  148. {
  149. 	//这里不用建大堆选出最大数,建堆的时间复杂度为O(N)
  150. 	// 取出最大数后再N-1个数进行建堆，执行次数为N-1
  151. 	//n个数，执行次数为N+N-1+N-2.....+1;时间复杂度为O(N^2)
  152. 	//，和冒泡排序时间复杂度为一样，没有时间上的优势
  153. 	for(int i=(n-1-1)/2;i>=0;i--)
  154. 	{
  155. 		AdjustDown(a, n, i);
  156. 	}
  157. 	//对数组进行升序排列
  158. 	//需要建大堆
  159. 	//收尾交换
  160. 	//把最后一个值不放在堆中,建大堆选出最大数，将其放在最后
  161. 	int end = n-1;
  162. 	while (end > 0)
  163. 	{
  164. 		Swap(&a[end], &a[0]);
  165. 		AdjustDown(a, end, 0);
  166. 		end--;
  167. 	}
  168. }

Heap.h

  1. #define  _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<assert.h>
  6. #include<stdbool.h>
  7. #include<string.h>
  8. #include<time.h>
  9.  
  10. typedef int HPDataType;
  11.  
  12. typedef struct Heap
  13. {
  14. 	HPDataType* a;
  15. 	int size;
  16. 	int capacity;
  17. }HP;
  18.  
  19. void HPInit(HP* php);
  20. void HPInitArray(HP* php, HPDataType* a, int n);
  21.  
  22. void HPDestroy(HP* php);
  23. // 插入后保持数据是堆
  24. void HPPush(HP* php, HPDataType x);
  25. HPDataType HPTop(HP* php);
  26.  
  27. // 删除堆顶的数据
  28. void HPPop(HP* php);
  29.  
  30. void HPSort(HPDataType* a, int n);
  31.  
  32. bool HPEmpty(HP* php);
  33.  
  34. void AdjustUp(HPDataType* a, int child);
  35. void AdjustDown(HPDataType* a, int n, int parent);
  36. void Swap(HPDataType* px, HPDataType* py);

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/681455
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号