排序算法 —— 堆排序

引言

此文基于《经典数据结构——堆的实现》中堆结构，实现一个以堆处理排序的算法。

一、算法思想

基于堆结构的堆排序的算法思想非常简单，循环获取大根堆中的最大值（0位置的根节点）放到堆的末尾，直到将堆拿空。

由于一个现成的大根堆可以实现 O(1) 时间复杂度的最大值返回，因此堆排序的主要时间消耗就是在 heapInsert 或 heapify 这类维护大根堆结构的过程上。

二、代码演示

首先将数组从0开始，模拟逐个放入的过程，循环 heapInsert 建堆。

然后以整个数组为堆，模拟循环取出 0 位置（最大值）的操作，循环 heapify。

小提示，取出的最大值你可以放在原数组中（即堆尾位置，由于拿出元素会导致堆缩小，数组末尾会有空余位置），也可以新创建一个同长数组放入，这对于排序本身并无影响，只不过是会增加额外的空间复杂度。

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2)
            return;
        // 整体变为大根堆
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        // 以整个数组作为堆大小，假设此堆已满
        int heapSize = arr.length;

        swap(arr, 0, --heapSize);
        while (heapSize > 0) {
            swap(arr, 0, --heapSize);
            heapify(arr, 0, heapSize);
        }
    }

模拟入堆的 heapInsert 、和模拟出堆的 heapify：

    // heapInsert
    private static void heapInsert(int[] arr, int index) {
        int father = (index - 1) / 2;
        while (arr[index] > arr[father]) {
            swap(arr, index, father);
            index = father;
            father = (index - 1) / 2;
        }
    }
    // heapify
    private static void heapify(int[] arr, int index, int heapSize) {
        int leftIdx = index * 2 + 1;
        while (leftIdx < heapSize) {
            int largest = leftIdx + 1 < heapSize && arr[leftIdx] < arr[leftIdx + 1] ? leftIdx + 1 : leftIdx;
            largest = arr[index] < arr[largest] ? largest : index;
            if (index == largest)
                break;
            else {
                swap(arr, index, largest);
                index = largest;
                leftIdx = index * 2 + 1;
            }
        }
    }
    // 交换数组元素
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

完整代码及对数器：

public class HeapSort {

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2)
            return;
        // 整体变为大根堆
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        // 以整个数组作为堆大小，假设此堆已满
        int heapSize = arr.length;

        swap(arr, 0, --heapSize);
        while (heapSize > 0) {
            swap(arr, 0, --heapSize);
            heapify(arr, 0, heapSize);
        }
    }

    private static void heapInsert(int[] arr, int index) {
        int father = (index - 1) / 2;
        while (arr[index] > arr[father]) {
            swap(arr, index, father);
            index = father;
            father = (index - 1) / 2;
        }
    }

    /**
     * 结合了两个方向的入堆方式
     *
     * @param arr
     * @param index
     * @param heapSize
     */
    private static void heapifyNew(int[] arr, int index, int heapSize) {
        if (index == 0) {
            // 向下
            int left = index * 2 + 1;
            while (left < heapSize) {
                int largest = left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;
                largest = arr[index] < arr[largest] ? largest : index;
                if (largest == index) break;
                else {
                    swap(arr, index, largest);
                    index = largest;
                    left = index * 2 + 1;
                }
            }
        } else if (index == heapSize - 1) {
            // 向上
            int father = (index - 1) / 2;
            while (arr[index] > arr[father]) {
                swap(arr, index, father);
                index = father;
                father = (index - 1) / 2;
            }
        }
    }

    private static void heapify(int[] arr, int index, int heapSize) {
        int leftIdx = index * 2 + 1;
        while (leftIdx < heapSize) {
            int largest = leftIdx + 1 < heapSize && arr[leftIdx] < arr[leftIdx + 1] ? leftIdx + 1 : leftIdx;
            largest = arr[index] < arr[largest] ? largest : index;
            if (index == largest)
                break;
            else {
                swap(arr, index, largest);
                index = largest;
                leftIdx = index * 2 + 1;
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // for test
    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }

    // for test
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    // for test
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    // for test
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
            return false;
        }
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }

    // for test
    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    // for test
    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 100;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            heapSort(arr1);
            comparator(arr2);
            if (!isEqual(arr1, arr2)) {
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");

        int[] arr = generateRandomArray(maxSize, maxValue);
        printArray(arr);
        heapSort(arr);
        printArray(arr);
    }
}

三、时间复杂度

结论：堆排序的时间复杂度是O(N * logN)。

简单说明一下各个步骤的大体时间复杂度，详细推导不做讨论。

堆排序突破不了这个复杂度，为什么？这是因为第二步取值调整无法改变O(N* logN)，同时，基于比较的排序方法也没有比 O(N * logN) 更好的排序了。

首先，heapInsert 的时间复杂度是 O(logN) ，这个不难理解，因为是二叉树，每次向上比较和交换的次数只与堆的层高有关，而层高又约等于 logN ，因此调整一次的复杂度就是 O(logN)。

而建堆的过程是循环 heapInsert，因此建堆的时间复杂度就是 O(N * logN)。

同样，heapipfy 的时间复杂度也是 O(logN)，每次下沉也只与层高有关。而循环下沉同样也是 O(N * logN)。

因此，除去一些常数时间复杂度和倍数项，最终可知堆排序的时间复杂度是 O(N * logN)。

扩展--建堆的两种方式

上面的代码以模拟入堆的方式建堆，循环 heapInsert ，时间复杂度是 O(N * logN)。

但是如果使用反向建堆 ，从数组最后一个元素开始，循环 heapify，那么时间复杂度会降 O(N)。

// O(N)
for (int i = arr.length - 1; i >= 0; i--) {
	heapify(arr, i, arr.length);
}

首先不考虑复杂度，但看这种建堆方式，就要比 heapInsert 更优，因为 heapify 是指定 i 位置向下沉，由于最后一层元素更多，而这些元素不需要向下沉，因此可以减少很多不必要的操作。那么每一层从下往上越来越少，向下沉的元素也会越来越少。

再来看时间复杂度。

我们从最后一个元素开始，执行 heapify，由于heapify是向下比较向下沉，因此叶子节点只看一眼自身就直接返回了，而堆的叶子节点数量大概是 N/2 数量级，因此，时间消耗公式可以是：

T(N) = (N / 2) * 1 + (N/4) * 2 + (N/8) * 3 + (N/16) * 4 ... 

这个算式如何求解？可以使用数学上常用的 扩倍相减：

2 * T(N) = N + (N / 2) * 2 + (N / 4) * 3 + (N / 8) * 4 ...

最后两式错位相减，得到 T(N) = N + N/2 + N/4 + N/8 + N/16.... 等比数列求和，当 N 无限大时，收敛于 O(N)。