复杂度nlog(n)之堆排序

1.简单的介绍

堆排序是利用特殊二叉树大顶堆和小顶堆进行排序的算法，通过将数组转化成大顶堆（满足array[n]>array[2n+1]和array[n]>array[2n+2]这两个条件），然后将array[0]和array[array.length-1]交换，然后将无序区重新构建大顶堆。重复之前的步骤知道所有的都变成有序区。
步骤：
1.将数组变成大顶堆。
2.将array[0]和array[array.length-1]交换。
3.将无序区域重新构建大顶堆。
4.循环直至所有区域都有序。

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度
nlog(n)	nlog(n)	nlog(n)	O(1)

2.核心的maxheap函数

    public static void maxheap(int[] array, int length, int index) {
        int left = getleftindex(index);
        int right = getrightindex(index);
        int largest = index;
        if (left < length && array[left] > array[largest]) {
            largest = left;
        }
        if (right < length && array[right] > array[largest]) {
            largest = right;
        }
        if (largest != index) {
            int temp = array[index];
            array[index] = array[largest];
            array[largest] = temp;
            maxheap(array, length, largest);
        }
    }

上面就是利用递归建立最大堆得过程，大致的步骤是这样的：
1.先找到当前节点的左子树。
2.找到当前节点的右子树。
3.在左右子树不超出范围的情况下，比较三者的大小，将最大的节点记录下。
4.假如当前最大的节点不是父节点，那么交换他们的位置，满足父节点最大。因为移动了下面子树，所以移动的子树要重新建堆。

3.完整的代码

public static void buildmaxheap(int[] array) {
        int startindex = getparentindex(array.length - 1);
        for (int i = startindex; i >= 0; i--) {
            maxheap(array, array.length, i);
        }
    }

    public static void maxheap(int[] array, int length, int index) {
        int left = getleftindex(index);
        int right = getrightindex(index);
        int largest = index;
        if (left < length && array[left] > array[largest]) {
            largest = left;
        }
        if (right < length && array[right] > array[largest]) {
            largest = right;
        }
        if (largest != index) {
            int temp = array[index];
            array[index] = array[largest];
            array[largest] = temp;
            maxheap(array, length, largest);
        }
    }

    public static void heapsort(int[] array, int length) {
        buildmaxheap(array);
        for (int i = length - 1; i > 0; i--) {
            int data = array[0];
            array[0] = array[i];
            array[i] = data;
            maxheap(array, i, 0);
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static int getparentindex(int index) {
        return (index - 1) >> 1;
    }

    public static int getleftindex(int index) {
        return (index << 1) + 1;
    }

    public static int getrightindex(int index) {
        return (index << 1) + 2;
    }

    public static void main(String[] args) {
        int[] array = { 2, 1, 4, 3, 5, 6, 4, 9, 7, 8 };
        heapsort(array, array.length);
    }

利用递归不停地分割，一直到start和end相同时，就是数组被分成一个一个数的时候，这样这个数据就变成有序的了。