堆排序算法

定义：

• 时间复杂度：最好O(nlogn)、最差O(nlogn)、平均O(nlogn)

• 空间复杂度：O(1)

• 稳定否：不稳定

• 思想：选择排序思想，就是挑取最大值、最小值的效率是O(logn)

• 很重要的两个方法：下潜、建立堆

实现：

/**
 * 堆排序（下潜、建堆）
 *
 * @param array 排序数组
 * @return 排序结果
 */
public static int[] heapSort(int[] array) {
    heapify(array, array.length);
    for (int i = array.length - 1; i > 0; i--) {
        swap(array, 0, i);
        down(array, 0, i - 1);
    }
    return array;
}

public static void heapify(int[] array, int size) {
    for (int i = size / 2 - 1; i >= 0; i--) {
        down(array, i, size);
    }
}

public static void down(int[] array, int parent, int size) {
    while (true) {
        int left = parent * 2 + 1;
        int right = left + 1;
        int max = parent;
        if (left < size && array[left] > array[max]) {
            max = left;
        }
        if (right < size && array[right] > array[max]) {
            max = right;
        }
        if (max == parent) {
            break;
        }
        swap(array, parent, max);
        parent = max;
    }
}