堆排序

堆排序，建立在堆这种结构上。一般的堆可以建立在数组上，但也可以用链表结构来表示。有序堆满足，每个节点的键值要比它所有孩子的键值都大。

[cpp:showcolumns] view plaincopyprint?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. #include <iostream>   
2. using namespace std;  
3. typedef double Elem;  
4. /* 自顶向下堆化（大根堆） 
5. fixDown(Elem* eArray, int k, int N) 
6. 问题功能描述： 
7. 假设原来的堆是有序的，只是位置k上的键值下降了，将位置k上的元素放到一个适当的位置上，使其满足堆的条件。 
8. procedure (eArray, k , N) 
9. while (2 * k <= N) // 存在孩子节点，"="的时候只有一个孩子节点 
10. {    
11.     找到键值较大的孩子节点的位置j（注意只有一个孩子节点的情况） 
12.     if eArray[k] < eArray[j]  
13.     { 
14.         交换位置k和位置j上的元素； 
15.         将k设置为j； //因为交换位置k和位置j上的元素之后，以位置j上的元素为根的堆变得无序了，所以继续堆化 
16.     } 
17.     else 
18.     { 
19.         当前位置k就是eArray[k]的最终位置； 
20.         跳出循环； 
21.     } 
22. } 
23. */  
24.   
25. inline bool Less(Elem& e1, Elem& e2) {return e1 < e2;}  
26. inline void Exch(Elem& e1, Elem& e2) { Elem e = e1; e1 = e2; e2 = e;}  
27.   
28. void FixDown(Elem* eArray, int k, int N)  
29. {  
30.     int j = 2 * k; // 键值最大的孩子节点的位置  
31.     while (j <= N)  
32.     {  
33.         // 找到键值最大的孩子节点   
34.         if (j < N && Less(eArray[j], eArray[j+1]))  
35.         {  
36.             j++;  
37.         }  
38.   
39.         if (!Less(eArray[k], eArray[j]))  
40.         {  
41.             break;  
42.         }  
43.           
44.         Exch(eArray[k], eArray[j]);  
45.         k = j;  
46.         j = 2 * k;  
47.     }  
48. }  
49.   
50. /* 堆排序 
51. 1、自底向上，自左向右构建堆 
52. 2、将第一个元素（键值最大）与最后一个元素交换，堆的元素数目减1，调整堆。 
53. 3、循环执行第2步，直到堆为空。 
54. */  
55.   
56. /*eArray 为元素数组（下标从1开始），totalNum为元数目*/  
57. void HeapSort(Elem* eArray, int totalNum)  
58. {  
59.     int const N = totalNum;  
60.     //  构建堆   
61.     int k;  
62.     for (k = totalNum / 2; k >= 1; k--)  
63.     {  
64.         FixDown(eArray, k, totalNum);  
65.     }  
66.        
67.     while (totalNum > 1)  
68.     {  
69.         Exch(eArray[1], eArray[totalNum]);  
70.         FixDown(eArray, 1, --totalNum);   
71.     }  
72. }  
73.   
74.   
75. int main()  
76. {     
77.     Elem a[10] = {0, 1, 2, 9, 4, 8, 6, 7, 5, 3};  
78.     int totalNum = 9;  
79.   
80.     cout << "未排序前的序列：" << endl;  
81.     int i;  
82.     for (i = 1; i < totalNum; i++)  
83.     {  
84.         cout << a[i] << ", ";  
85.     }  
86.     cout << a[totalNum] << endl;  
87.     HeapSort(a, totalNum);  
88.     cout << "排序之后的序列：" << endl;  
89.   
90.     for (i = 1; i < totalNum; i++)  
91.     {  
92.         cout << a[i] << ", ";  
93.     }  
94.     cout << a[totalNum] << endl;  
95.     return 0;  
96. }