堆排序解析

首先要了解堆的性质，我这里简答总结一下（这里说的是小堆）：
1、堆是一棵完全二叉树
2、对于大堆中的任何一个非叶子节点，节点的值必须小于左右孩子节点值。

由此可知，对于小堆而言，根节点就是最小值了，那么我们每次拿走根节点，拿走的顺序就是递增序列的。
排序的元素在数组中，而堆也是一棵完全二叉树，所以直接用数组表示二叉树。
对于完全二叉树中的K节点，其满足一下性质：
1、K节点的父节点为( k - 1 ) / 2
2、K节点的左子节点为2K + 1
3、K节点的右子节点为2K +  2

所以堆排序的步骤如下：
1、填充二叉树元素，由于我们直接用源数据表示二叉树，所以这里不用写了。
2、由堆的性质可知，任何叶子节点都是满足堆的性质的，所以找到第一个非叶子节点的节点，从该节点开始，调整所有节点，让他们满足堆的性质
3、移走堆的根节点，得到当前的最大值。
4、将最后一个节点移至根节点，此时除了根节点外其余节点都是满足要求的，重新调整堆，重复第3步。

[cpp]  view plain copy

1. void heapAdjust(int a[], int n, int index)  //建立的是小根堆  
2. {  
3.         int l = 2 * index + 1;      //左子节点索引  
4.         int r = 2 * index + 2;      //右子节点索引  
5.         if ( r >= n && l >= n ) return; //该节点没有子节点  
6.   
7.         int left = 0x7FFFFFFF, right = 0x7FFFFFFF;  
8.         if ( l < n ) left = a[l];  
9.         if ( r < n ) right = a[r];  
10.   
11.         if (a[index] <= left && a[index] <= right ) return; //节点值小于左右子节点值，符合条件，直接返回  
12.         if (left < right) //节点与较小的子节点交换  
13.         {  
14.                 int t = a[index];  
15.                 a[index] = left;  
16.                 a[l] = t;  
17.                 heapAdjust(a, n, l);  
18.         }  
19.         else  
20.         {  
21.                 int t = a[index];  
22.                 a[index] = right;  
23.                 a[r] = t;  
24.                 heapAdjust(a, n, r);  
25.         }  
26. }  
27.   
28. void heapSort(int a[], int n)  
29. {  
30.         for ( int i = (n - 1) / 2; i >= 0; --i) //最后一个非叶子节点，也就是左后一个叶子节点的父节点  
31.         {  
32.                 heapAdjust(a, n, i);  
33.         }  
34.         while (n > 0)  
35.         {  
36.                 printf("%d ", a[0]);  
37.                 int t = a[0]; //移走最小值  
38.                 a[0] = a[n-1];   
39.                 a[n-1] = t;     
40.                 n--;          //堆变小  
41.                 heapAdjust(a, n, 0);  
42.         }  
43. }  
44.   
45. int main()  
46. {  
47.         int a[] = {3, 5, 1, 4, 7, 3, 2, 5, 3, 8};  
48.         for ( int i = 0; i < 10; ++i)  
49.         {  
50.                 printf("%d ", a[i]);  
51.         }  
52.         printf("\n");  
53.         heapSort(a, 10);  
54.         printf("\nAfter sort:\n");  
55.         for ( int i = 0; i < 10; ++i)  
56.         {  
57.                 printf("%d ", a[i]);  
58.         }  
59.         printf("\n");  
60. }  

由于建立的是小根堆，所以最后得到是将序列。

最后附一个堆排的动画