排序算法——堆排序（递归版本）

堆积排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法。堆积树是一个近似完整二叉树的结构，并同时满足堆积属性：即子结点的键值或索引总是小于（或者大于）它的父结点。

在堆积树的数据结构中，堆积树中的最大值总是位于根节点。堆积树中定义以下几种操作：
1.最大堆积调整（max_heapify）：将堆积树的末端子结点作调整,使得子结点永远小于父结点
2.建立最大堆积（build_max_heap）：将堆积树所有数据重新排序
3.堆积排序（heap_sort）：移除位在第一个数据的根结点,并做最大堆积调整的递归运算

最坏时间复杂度 O(nlogn)
堆排序是不稳定的排序算法

Code:

1. #include <stdio.h>   
2.   
3. void max_heapify(int a[], int parent, int heap_size)   
4. {   
5.     int l, r, largest, temp;   
6.        
7.     l = (parent << 1) + 1;   
8.     r = l + 1;   
9.     largest = parent;   
10.   
11.     if (l <= heap_size && a[l] > a[largest]) {   
12.         largest = l;   
13.     }   
14.     if (r <= heap_size && a[r] > a[largest]) {   
15.         largest = r;   
16.     }   
17.     if (largest != parent) {   
18.         temp = a[parent];   
19.         a[parent] = a[largest];   
20.         a[largest] = temp;   
21.         max_heapify(a, largest, heap_size);   
22.     }   
23. }   
24.  
25. void build_max_heap(int a[], int heap_size)   
26. {   
27.     int i;   
28.     for (i = heap_size / 2; i >= 0; i--) {   
29.         max_heapify(a, i, heap_size);   
30.     }   
31. }   
32.   
33. void heap_sort(int a[], int heap_size)   
34. {   
35.     int i, temp;   
36.     build_max_heap(a, heap_size);   
37.     for (i = heap_size; i >= 0; i--)   
38.     {   
39.         temp = a[i];   
40.         a[i] = a[0];   
41.         a[0] = temp;   
42.         heap_size--;   
43.         max_heapify(a, 0, heap_size);   
44.     }   
45. }   
46.   
47. int main()   
48. {   
49.     int a[] = {46,79,56,38,40,84}, i;   
50.     int size = sizeof(a) / sizeof(int);   
51.     heap_sort(a, size - 1);   
52.   
53.     for (i = 0; i < size; i++) {   
54.         printf("%d ", a[i]);   
55.     }   
56.     return 0;   
57. }