Algorithm | 排序算法之堆排序

相关知识

• 排序算法之冒泡排序
• 排序算法之快速排序
• 排序算法之直接插入排序
• 排序算法之希尔排序
• 排序算法之直接选择排序
• 排序算法之堆排序
• 排序算法之归并排序
• 排序算法总结

基本思想

基本思想：堆化，堆的删除

代码实现

实现1：交换

public static void heapSort(int[] array) {
    toHeap(array);

    for (int i = array.length - 1; i > 0; i--) {
        int tmp = array[i];
        array[i] = array[0];
        array[0] = tmp;
        heapDown(array, i, 0);
    }
}

private static void toHeap(int[] array) {
    for (int i = array.length / 2 - 1; i >= 0; i--) {
        heapDown(array, array.length, i);
    }
}

private static void heapDown(int[] array, int length, int i) {
    for (int j = 2 * i + 1; j < length; i = j, j = 2 * i + 1) {
        if (j + 1 < length && array[j + 1] > array[j]) {
            j++;
        }

        if (array[i] >= array[j]) {
            break;
        }

        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}

实现2：上移

public static void heapSort(int[] array) {
    toHeap(array);

    for (int i = array.length - 1; i > 0; i--) {
        int tmp = array[i];
        array[i] = array[0];
        array[0] = tmp;
        heapDown(array, i, 0);
    }
}

private static void toHeap(int[] array) {
    for (int i = array.length / 2 - 1; i >= 0; i--) {
        heapDown(array, array.length, i);
    }
}

private static void heapDown(int[] array, int length, int i) {
    int tmp = array[i];
    for (int j = 2 * i + 1; j < length; i = j, j = 2 * i + 1) {
        if (j + 1 < length && array[j + 1] > array[j]) {
            j++;
        }

        if (tmp >= array[j]) {
            break;
        }

        array[i] = array[j];
    }
    array[i] = tmp;
}

算法复杂度

• 时间复杂度：O(NlogN)
• 空间复杂度：O(1)

算法稳定性

算法稳定性：不稳定