[算法系列之一]堆排序

前序：

(二叉)堆数据结构是一种数组对象，它可以被视为一棵完全二叉树。树中每个节点与数组中存放该节点值的那个元素对应。

树的每一层都是填满的，最后一层除外。

树的根为a[1] （在这里是从1开始的，也可以从0开始），给定了某个节点的下标i，其父节点为i/2，左二子为2*i，右儿子为2*i+1。

二叉堆满足二个特性：

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

2．每个结点的左子树和右子树都是一个二叉堆（最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。

当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。

保持堆的性质：

MaxHeap是对最大堆进行操作的最重要的子程序。

以i为根的子树：

在算法每一步中，从a[i], a[Left(i)], a[Right(i)]找出最大值，并将其下标存在LargestIndex中。如果a[i]是最大的，则以i为根的子树已是最大堆,程序结束。

否则i的某个子结点中有最大元素则交换a[i],a[LargetIndex],从而使i及子女满足堆性质。下标为LargestIndex的结点在交换后的值为a[i],以该结点为根的子树又有可能违反最大堆的性质，因而又要对该子树递归调用MaxHeap，重新使子树平衡。

[cpp] view plain copy

1. //调整以index为根的子树
2. //n：堆中元素个数
3. intMaxHeap(inta[],intindex,intn){
4. intLargestIndex=index;
5. //左子节点
6. intLeftIndex=2*index;
7. //右子节点
8. intRightIndex=2*index+1;
9. if(LeftIndex<=n&&a[LeftIndex]>a[LargestIndex]){
10. LargestIndex=LeftIndex;
11. }
12. if(RightIndex<=n&&a[RightIndex]>a[LargestIndex]){
13. LargestIndex=RightIndex;
14. }
15. //如果a[index]是最大的，则以index为根的子树已是最大堆否则index的子节点有最大元素
16. //则交换a[index],a[LargetIndex],从而使index及子女满足堆性质
17. inttemp;
18. if(LargestIndex!=index){
19. //交换a[index],a[LargetIndex]
20. temp=a[index];
21. a[index]=a[LargestIndex];
22. a[LargestIndex]=temp;
23. //重新调整以LargestIndex为根的子树
24. MaxHeap(a,LargestIndex,n);
25. }
26. return0;
27. }

建堆：

我们可以自底向上的用MaxHeap来将一个数组a[1-n]变成一个最大堆，子数组a[n/2+1,........n]中的元素是树中的叶子，因此每个都可以看做只含一个元素的堆，满足最大堆的要求，不用调整。所以只需调整以a[n/2........1]中元素为根的子树使之成为最大堆。

[cpp] view plain copy

1. //建堆：将一个数组a[1-n]变成一个最大堆
2. intBuildMaxHeap(inta[],intn){
3. inti;
4. //子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子
5. for(i=n/2;i>=1;i--){
6. //调整以i为根节点的树使之成为最大堆
7. MaxHeap(a,i,n);
8. }
9. return0;
10. }

a数组

16

7

3

20

17

8

初始堆：

自底向上从最后一个非叶节点开始调整：

（a） （b） （c） （d）

每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。

堆排序：

开始时，堆排序先用BuildMaxHeap将输入数组a[1-n]构造成一个最大堆。又因为数组中最大元素在根a[1]，则可以通过它与a[n]交换来达到最终的正确位置。现在，如果从堆中”去掉“结点n(不是真的删除，而是通过修改堆的元素个数n)，可以很容易的将a[1-(n-1)]建成最大堆。原来根的子女依旧是最大堆，二新交换的根元素很有可能违背最大堆的性质。这时调用MaxHeap重新调整一下。在a[1-(n-1)]中构造出最大堆。堆排序不断重复这一过程，堆的大小由n-1一直降到2.从而完成排序的功能

[cpp] view plain copy

1. //堆排序
2. intHeapSort(inta[],intn){
3. inttemp;
4. //BulidMaxHeap将输入数组构造一个最大堆
5. BuildMaxHeap(a,n);
6. //数组中最大元素在根a[1]，则可以通过它与a[n]交换来达到最终的正确位置
7. for(inti=n;i>=2;i--){
8. //交换
9. temp=a[i];
10. a[i]=a[1];
11. a[1]=temp;
12. //a[i]已达到正确位置，从堆中去掉
13. n--;
14. //重新调整，保持最大堆的性质
15. MaxHeap(a,1,n);
16. }
17. return0;
18. }

（a） （b） （c） （d）

（e） （f） （g）

（h） （i） （j） （k）

红色为排序后的结果；

代码：

[cpp] view plain copy

1. #include<stdio.h>
2. #include<stdlib.h>
4. //调整堆
5. intMaxHeap(inta[],intindex,intn){
6. intLargestIndex=index;
7. //左子节点
8. intLeftIndex=2*index;
9. //右子节点
10. intRightIndex=2*index+1;
11. if(LeftIndex<=n&&a[LeftIndex]>a[LargestIndex]){
12. LargestIndex=LeftIndex;
13. }
14. if(RightIndex<=n&&a[RightIndex]>a[LargestIndex]){
15. LargestIndex=RightIndex;
16. }
17. //如果a[index]是最大的，则以index为根的子树已是最大堆否则index的子节点有最大元素
18. //则交换a[index],a[LargetIndex],从而使index及子女满足堆性质
19. inttemp;
20. if(LargestIndex!=index){
21. //交换a[index],a[LargetIndex]
22. temp=a[index];
23. a[index]=a[LargestIndex];
24. a[LargestIndex]=temp;
25. //重新调整以LargestIndex为根的子树
26. MaxHeap(a,LargestIndex,n);
27. }
28. return0;
29. }
32. //建堆：将一个数组a[1-n]变成一个最大堆
33. intBuildMaxHeap(inta[],intn){
34. inti;
35. //子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子
36. for(i=n/2;i>=1;i--){
37. //调整以i为根节点的树使之成为最大堆
38. MaxHeap(a,i,n);
39. }
40. return0;
41. }
43. //堆排序
44. intHeapSort(inta[],intn){
45. inttemp;
46. //BulidMaxHeap将输入数组构造一个最大堆
47. BuildMaxHeap(a,n);
48. //数组中最大元素在根a[1]，则可以通过它与a[n]交换来达到最终的正确位置
49. for(inti=n;i>=2;i--){
50. //交换
51. temp=a[i];
52. a[i]=a[1];
53. a[1]=temp;
54. //a[i]已达到正确位置，从堆中去掉
55. n--;
56. //重新调整，保持最大堆的性质
57. MaxHeap(a,1,n);
58. }
59. return0;
60. }
61. intmain(){
62. intn=6;
63. //a[0]不用，堆的根结点是从1开始的
64. inta[]={0,3,17,8,7,16,20};
65. HeapSort(a,n);
66. for(inti=1;i<=n;i++){
67. printf("%d",a[i]);
68. }
69. return0;
70. }