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

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
通常堆是通过一维数组来实现的。在起始数组为 0 的情形中：
父节点i的左子节点在位置 (2*i+1);
父节点i的右子节点在位置 (2*i+2);
子节点i的父节点在位置 floor((i-1)/2);

在堆的数据结构中，堆中的最大值总是位于根节点。堆中定义以下几种操作：
最大堆调整（maxHeapify）：将堆的末端子节点作调整，使得子节点永远小于父节点

创建最大堆（buildMaxHeap）：将堆所有数据重新排序

堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

现在给出C#实现的堆排序：

 public class HeapSort<T> : ISort<T> where T : IComparable<T>
    {
        public void Sort(T[] array, int startIndex, int endIndex)
        {
            //Heapify the array
            buildMaxHeap(array, startIndex, endIndex);
            //Sort from endIndex to (startIndex-1), 
            //when i=startIndex, then only one node left,then no any requirement to heapify it.
            for (int i = endIndex; i > startIndex; i--)
            {
                //swap array[i] and array[startIndex]
                T tmpT = array[i];
                array[i] = array[startIndex];
                array[startIndex] = tmpT;
                maxHeapify(array, startIndex, i - 1, startIndex);
            }
        }
        private void buildMaxHeap(T[] array, int startIndex, int endIndex)
        {
            //Leaf node is from (endIndex-startIndex+1)/2+1+startIndex to endIndex
            // //O(n*Log(n))
            for (int i = (endIndex - startIndex + 1) / 2 + startIndex; i >= startIndex; i--)
            {
                //O(Log(n))
                maxHeapify(array, startIndex, endIndex, i);
            }
        }

        //insert a new root node for two child maxHeap.
        private void maxHeapify(T[] array, int startIndex, int endIndex, int newRootIndex)
        {

            //int L = (newRootIndex - startIndex) * 2 + 1 + startIndex;
            int L = (newRootIndex - startIndex + 1) * 2 + startIndex - 1;//The array base is from 0.
            int R = L + 1;
            int tmpLargestIndex = newRootIndex;
            if (L <= endIndex && array[L].CompareTo(array[tmpLargestIndex]) > 0)
            {
                tmpLargestIndex = L;
            }
            if (R <= endIndex && array[R].CompareTo(array[tmpLargestIndex]) > 0)
            {
                tmpLargestIndex = R;
            }
            if (tmpLargestIndex != newRootIndex)
            {
                //swap array[tmpLargestIndex] and array[newRootIndex]
                T tmpT = array[tmpLargestIndex];
                array[tmpLargestIndex] = array[newRootIndex];
                array[newRootIndex] = tmpT;
                //MaxHeapify the child branch, the newRootIndex= tmpLargestIndex
                maxHeapify(array, startIndex, endIndex, tmpLargestIndex);
            }
        }
    }

作者：Andy Zeng

欢迎任何形式的转载，但请务必注明出处。

http://www.cnblogs.com/andyzeng/p/3699195.html