堆排序

 需要掌握的知识:

 大根堆

 根节点的值始终大于孩子节点的值的树结构如下

      9
     / /
    8   6
   / / / /
  7  1 4  2
 /
3

然后每次用根节点与最后一个节点替换，并用剩下的节点构造大根堆

时间复杂度为O(n*logn)

1. #include <iostream>
2. using namespace std;
4. int cnt = 0; //计算次数
5. void Output(int array[], int n)
6. {
7.     printf("%d:/t/t ", cnt++);
8.     for (int i=1; i<n; i++)
9.     {
10.         printf("%d ", array[i]);
11.     }
12.     printf("/n");
13. }
15. void swap(int &a, int &b)
16. {
17.   printf("%d <--> %d/n", a, b);
18.   int temp;
19.   temp = a;
20.   a = b;
21.   b = temp;
22. }
24. /*
25.   root从最下层的根开始排序，树的节点序号从1开始，左节点＝2＊根节点
26.   index为节点数
27.   函数目的:建立大根堆(根节点始终大于孩子节点的树结构)
28.  */
29. void CreateHeap(int array[], int root, int index)
30. {
31.   int j;
32.   int temp;
33.   int finish;
34.   
35.   j = 2*root; //左孩子节点索引值
36.   temp = array[root]; //保存根节点
38.   finish = 0;
40.   while(j<=index && finish == 0)
41.     {
42.       if(j < index) //如果有右孩子
43.     if(array[j] < array[j+1]) //选出值大的节点
44.       j++;
45.       if(temp >= array[j]) //和父节点比较
46.     finish = 1;
47.       else //取出最大值的节点做父亲
48.     {
49.       array[j/2] = array[j];
50.       j = 2*j; //递归左节点
51.     }
52.     }
53.   array[j/2] = temp;
54. }
58. int main()
59. {
60.   int a[9] = {0,7,9,6,8,1,2,4,3};
61.   for(int k=8; k>0; k--)
62.     {
63.       a[9-k] = k+1;
64.     }
65.   for(int i=(8/2); i>0; i--)
66.     {
67.       CreateHeap(a, i, 8);
68.       Output(a,9);
69.     }
71.   for(int j=8; j>1; j--)
72.     {
73.       swap(a[j], a[1]);
74.       CreateHeap(a, 1, j-1);;
75.       Output(a,9);
76.     }
77.   return 0;
78. }

注意索引值从1开始，才有父节点索引＝子节点索引值/2