基于比较的算法之五：堆排序

 1  public class HeapSort<T> : ISort<T> where T : IComparable<T>
 2     {
 3         public void Sort(T[] array, int startIndex, int endIndex)
 4         {
 5             //Heapify the array
 6             buildMaxHeap(array, startIndex, endIndex);
 7             //Sort from endIndex to (startIndex-1), 
 8             //when i=startIndex, then only one node left,then no any requirement to heapify it.
 9             for (int i = endIndex; i > startIndex; i--)
10             {
11                 //swap array[i] and array[startIndex]
12                 T tmpT = array[i];
13                 array[i] = array[startIndex];
14                 array[startIndex] = tmpT;
15                 maxHeapify(array, startIndex, i - 1, startIndex);
16             }
17         }
18         private void buildMaxHeap(T[] array, int startIndex, int endIndex)
19         {
20             //Leaf node is from (endIndex-startIndex+1)/2+1+startIndex to endIndex
21             // //O(n*Log(n))
22             for (int i = (endIndex - startIndex + 1) / 2 + startIndex; i >= startIndex; i--)
23             {
24                 //O(Log(n))
25                 maxHeapify(array, startIndex, endIndex, i);
26             }
27         }
28 
29         //insert a new root node for two child maxHeap.
30         private void maxHeapify(T[] array, int startIndex, int endIndex, int newRootIndex)
31         {
32 
33             //int L = (newRootIndex - startIndex) * 2 + 1 + startIndex;
34             int L = (newRootIndex - startIndex + 1) * 2 + startIndex - 1;//The array base is from 0.
35             int R = L + 1;
36             int tmpLargestIndex = newRootIndex;
37             if (L <= endIndex && array[L].CompareTo(array[tmpLargestIndex]) > 0)
38             {
39                 tmpLargestIndex = L;
40             }
41             if (R <= endIndex && array[R].CompareTo(array[tmpLargestIndex]) > 0)
42             {
43                 tmpLargestIndex = R;
44             }
45             if (tmpLargestIndex != newRootIndex)
46             {
47                 //swap array[tmpLargestIndex] and array[newRootIndex]
48                 T tmpT = array[tmpLargestIndex];
49                 array[tmpLargestIndex] = array[newRootIndex];
50                 array[newRootIndex] = tmpT;
51                 //MaxHeapify the child branch, the newRootIndex= tmpLargestIndex
52                 maxHeapify(array, startIndex, endIndex, tmpLargestIndex);
53             }
54         }
55     }