堆排序

最大堆调整：

1、在对应的数组元素A[i], 左孩子A[LEFT(i)], 和右孩子A[RIGHT(i)]中找到最大的那一个，将其下标存储在largest中。

2、如果A[i]已经就是最大的元素，则程序直接结束。

3、否则，i的某个子结点为最大的元素，将A[largest]与A[i]交换。

4、再从交换的子节点开始，重复1,2,3步，直至叶子节点，算完成一次堆调整。

建堆：

建堆是一个通过不断的堆调整，使得整个二叉树中的数满足堆性质的操作。在数组中的话，我们一般从下标为n/2的数开始做堆调整，一直到下标为0的数(因为下标大于n/2的数都是叶子节点，其子树已经满足堆的性质了)。

01.#include <cstdio>  
02.#include <cstdlib>  
03.#include <cmath>  
04.using namespace std;  
05.   
06.int parent(int);  
07.int left(int);  
08.int right(int);  
09.void HeapAdjust(int [], int, int);  
10.void BuildHeap(int [], int);  
11.void print(int [], int);  
12.void HeapSort(int [], int);  
13.   
14./*返回父节点*/  
15.int parent(int i)  
16.{  
17.    return (int)floor((i - 1) / 2);  
18.}  
19.   
20./*返回左孩子节点*/  
21.int left(int i)  
22.{  
23.    return (2 * i + 1);  
24.}  
25.   
26./*返回右孩子节点*/  
27.int right(int i)  
28.{  
29.    return (2 * i + 2);  
30.}  
31.   
32./*对以某一节点为根的子树做堆调整(保证最大堆性质)*/  
33.void HeapAdjust(int A[], int i, int heap_size)  
34.{  
35.    int l = left(i);  
36.    int r = right(i);  
37.    int largest;  
38.    int temp;  
39.    if(l < heap_size && A[l] > A[i])  
40.    {  
41.        largest = l;  
42.    }  
43.    else  
44.    {  
45.        largest = i;  
46.    }  
47.    if(r < heap_size && A[r] > A[largest])  
48.    {  
49.        largest = r;  
50.    }  
51.    if(largest != i)  
52.    {  
53.        temp = A[i];  
54.        A[i] = A[largest];  
55.        A[largest] = temp;  
56.        HeapAdjust(A, largest, heap_size);  
57.    }  
58.}  
59.   
60./*建立最大堆*/  
61.void BuildHeap(int A[]，int heap_size)  
62.{  
63.    for(int i = (heap_size-2)/2; i >= 0; i--)  
64.    {  
65.        HeapAdjust(A, i, heap_size);  
66.    }  
67.}  
68.   
69./*输出结果*/  
70.void print(int A[]， int heap_size)  
71.{  
72.    for(int i = 0; i < heap_size;i++)  
73.    {  
74.        printf("%d ", A[i]);  
75.    }  
76.    printf("
");  
77.}  
78.   
79./*堆排序*/  
80.void HeapSort(int A[], int heap_size)  
81.{  
82.    BuildHeap(A, heap_size);  
83.    int temp;  
84.    for(int i = heap_size - 1; i >= 0; i--)  
85.    {  
86.        temp = A[0];  
87.        A[0] = A[i];  
88.        A[i] = temp;  
89.        HeapAdjust(A, 0, i);  
90.    }  
91.    print(A, heap_size);  
92.}  
93.   
94./*测试，对给定数组做堆排序*/  
95.int main(int argc, char* argv[])  
96.{  
97.    const int heap_size = 13;  
98.    int A[] = {19, 1, 10, 14, 16, 4, 7, 9, 3, 2, 8, 5, 11};  
99.    HeapSort(A, heap_size);  
100.    system("pause");  
101.    return 0;  
102.}