有意思的排序算法堆排序

　　堆排序，是一个非常优秀的排序算法，像合并排序而不像插入排序，其运行时间为O(nlgn)，像插入排序而不像合并排序，它是一种原地排序算法，所以说，堆排序将插入排序和合并排序的优点结合起来了。

　　堆排序借助于堆数据结构，（二叉）堆是一个数组，它可以被视为一棵完全二叉树，树中每个节点与数组中存放该节点值得那个元素对应。

　　堆排序算法可以分为以下几步：

　　1）  建立原先数列对应的最大（或最小）堆。

　　2）  重复n-1次循环，每次选出一个最大（或最小）值，并放到合适的位置。

　　Java代码实现如下：

public class HeapSort implements SortAlgorithm {

    private IntArray A = null;

    public HeapSort() {
        A = new IntArray();
    }

    private class IntArray {
        public int[] aArray = null;
        public int heapSize = 0;
    }

    @Override
    public void sort(int[] A) {
        maxHeapSort(A);
    }

    @Override
    public void sort(int[] A, boolean isInc) {
        if (isInc) {
            maxHeapSort(A);
        } else {
            minHeapSort(A);
        }
    }

    /**
     * 最大堆排序，升序
     * 
     * @param A
     *            int数组
     */
    private void maxHeapSort(int[] A) {
        this.A.aArray = A;
        this.A.heapSize = A.length;
        buildMaxHeap(this.A);
        for (int i = A.length; i >= 2; i--) {
            exchange(1, i);
            this.A.heapSize = this.A.heapSize - 1;
            maxHeapify(this.A, 1);
        }
    }

    /**
     * 最小堆排序，降序
     * 
     * @param A
     *            int数组
     */
    private void minHeapSort(int[] A) {
        this.A.aArray = A;
        this.A.heapSize = A.length;
        buildMinHeap(this.A);
        for (int i = A.length; i >= 2; i--) {
            exchange(1, i);
            this.A.heapSize = this.A.heapSize - 1;
            minHeapify(this.A, 1);
        }
    }

    /**
     * 使得以index为根的子树成为最大堆
     * 
     * @param A
     *            int数组
     * @param index
     *            以index为根，从1开始
     */
    private void maxHeapify(IntArray A, int index) {
        while (index < A.heapSize / 2 + 1) {
            int left = left(index);
            int right = right(index);
            int largest = 0;
            if (left <= A.heapSize && A.aArray[left - 1] > A.aArray[index - 1]) {
                largest = left;
            } else {
                largest = index;
            }
            if (right <= A.heapSize
                    && A.aArray[right - 1] > A.aArray[largest - 1]) {
                largest = right;
            }
            if (index != largest) {
                exchange(index, largest);
                index = largest;
            } else {
                index = A.heapSize / 2 + 1;
            }
        }
    }

    /**
     * 使得以index为根的子树成为最小堆
     * 
     * @param A
     *            int数组
     * @param index
     *            以index为根，从1开始
     */
    private void minHeapify(IntArray A, int index) {
        while (index < A.heapSize / 2 + 1) {
            int left = left(index);
            int right = right(index);
            int smallest = 0;
            if (left <= A.heapSize && A.aArray[left - 1] < A.aArray[index - 1]) {
                smallest = left;
            } else {
                smallest = index;
            }
            if (right <= A.heapSize
                    && A.aArray[right - 1] < A.aArray[smallest - 1]) {
                smallest = right;
            }
            if (index != smallest) {
                exchange(index, smallest);
                index = smallest;
            } else {
                index = A.heapSize / 2 + 1;
            }
        }
    }

    /**
     * 建最大堆
     * 
     * @param A
     *            int数组
     */
    private void buildMaxHeap(IntArray A) {
        for (int i = A.aArray.length / 2; i >= 1; i--) {
            maxHeapify(A, i);
        }
    }

    /**
     * 建最小堆
     * 
     * @param A
     *            int数组
     */
    private void buildMinHeap(IntArray A) {
        for (int i = A.aArray.length / 2; i >= 1; i--) {
            minHeapify(A, i);
        }
    }

    private int left(int index) {
        return 2 * index;
    }

    private int right(int index) {
        return 2 * index + 1;
    }

    private void exchange(int i, int j) {
        int temp = A.aArray[i - 1];
        A.aArray[i - 1] = A.aArray[j - 1];
        A.aArray[j - 1] = temp;
    }

}

PS：zhuangzhuang1988兄再来一个~O(∩_∩)O哈哈~