常见排序算法：堆排序

  1 

 2     /// <summary>
 3     /// Heap Sorting implemented in C# and tested
 4     /// </summary>
 5     public class HeapSortAsending
 6     {
 7         public static void Sort(int[] array)
 8         {
 9             BuildMaxHeap(array);
10 
11             for (int heapSize = array.Length - 1; heapSize >= 1; heapSize--)
12             {
13                 Swap(ref array[0], ref array[heapSize]);
14                 Heapify(array, 0, heapSize);
15             }
16         }
17 
18         private static void Heapify(int[] array, int i, int heapsize)
19         {
20             int l = Left(i);
21             int r = Right(i);
22 
23             int largest = i;
24             if ((l < heapsize) && (array[l] > array[i]))
25                 largest = l;
26 
27             if ((r < heapsize) && (array[r] > array[largest]))
28                 largest = r;
29 
30             if (largest != i)
31             {
32                 Swap(ref array[i], ref array[largest]);
33                 Heapify(array, largest, heapsize);
34             }
35         }
36 
37         private static void BuildMaxHeap(int[] array)
38         {
39             for (int i = array.Length / 2; i >= 0; i--)
40                 Heapify(array, i, array.Length);
41         }
42 
43         private static void Swap(ref int a, ref int b)
44         {
45             int tmp = a;
46             a = b;
47             b = tmp;
48         }
49 
50         private static int Left(int i)
51         {
52             return 2 * i;
53         }
54 
55         private static int Right(int i)
56         {
57             return 2 * i + 1;
58         }
59     }

 

 

 

 1 /*
 2  ============================================================================
 3  Name        : HeapSort.c
 4  Author      : Gump Yin
 5  Version     : 1.0
 6  Copyright   : http://www.cnblogs.com/BpLoveGcy;http://zh.wikipedia.org/zh-cn/%E5%A0%86%E7%A9%8D%E6%8E%92%E5%BA%8F
 7  Description : Heapsort Implemented by C
 8  ============================================================================
 9  */
10 
11 #include<stdio.h>
12 #include<stdlib.h>
13 #include<math.h>
14 #define HEAP_SIZE 13
15 int left(int i);
16 int right(int i);
17 
18 void Max_Heapify(int A[], int i, int heap_size);
19 void Build_Max_Heap(int A[]);
20 void HeapSort(int A[], int heap_size);
21 void Swap(int *a, int *b);
22 
23 void print(int A[]);
24 
25 // left child
26 int left(int i) {
27     return 2 * i;
28 }
29 
30 // right child
31 int right(int i) {
32     return 2 * i + 1;
33 }
34 
35 void Swap(int *a, int *b) {
36     int tmp = *a;
37     *a = *b;
38     *b = tmp;
39 }
40 
41 void Max_Heapify(int A[], int i, int heap_size) {
42     int l = left(i);
43     int r = right(i);
44 
45     int largest = i;
46     if (l < heap_size && A[l] > A[i]) {
47         largest = l;
48     }
49 
50     if (r < heap_size && A[r] > A[largest]) {
51         largest = r;
52     }
53     if (largest != i) {
54         Swap(&A[i], &A[largest]);
55         Max_Heapify(A, largest, heap_size);
56     }
57 }
58 
59 void Build_Max_Heap(int A[]) {
60     int i;
61     for (i = HEAP_SIZE; i >= 0; i--) {
62         Max_Heapify(A, i, HEAP_SIZE);
63     }
64 }
65 
66 void print(int A[]) {
67     int i;
68     for (i = 0; i < HEAP_SIZE; i++) {
69         printf("%d ", A[i]);
70     }
71     printf("\n");
72 }
73 
74 void HeapSort(int A[], int heap_size) {
75     Build_Max_Heap(A);
76 
77     int i;
78     for (i = heap_size - 1; i >= 1; i--) {
79         Swap(&A[0], &A[i]);
80         heap_size = heap_size - 1;
81         Max_Heapify(A, 0, heap_size);
82     }
83     print(A);
84 }
85 
86 int main() {
87     int A[HEAP_SIZE] = { 0, 1, 10, 14, 16, 4, 7, 9, 3, 2, 8, 5, 11 };
88     //int A[HEAP_SIZE] = { 19, 1, 10, 14, 16, 4, 7, 9, 3, 2, 8, 5, 11 };
89     print(A);
90     HeapSort(A, HEAP_SIZE);
91     print(A);
92 
93     return 0;
94 }
95 

 

 

 

 

ref:http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.4.2.1.htm 

    　堆排序可通过树形结构保存部分比较结果，可减少比较次数。