【排序算法】堆排序

什么是堆排序？

摘自漫画算法：

记得二叉堆的特性是什么吗？

最大堆的堆顶是整个堆中最大的元素。
最小堆的堆顶是整个堆中最小的元素。

以最大堆为例，如果删除一个最大堆的堆顶（并不是完全删除，而是跟末尾的节点交换位置），经过自我调整，第2大的元素就会被交换上来，成为最大堆的新堆顶。

堆排序1.png

如上图所示，在删除值为10的堆顶节点后，经过调整，值为9的新节点就会顶替上来。在删除值为9的堆顶节点后，经过调整，值为8的新节点就会顶替上来。

堆排序5.png

由于二叉堆的这个特性，每一次删除旧堆顶，调整后的新堆顶都是大小仅次于旧堆顶的节点。那么只要反复删除堆顶，反复调整二叉堆，所得到的集合就会成为一个有序集合，过程如下。

删除节点9，节点8成为新堆顶。

堆排序2.png

删除节点8，节点7成为新堆顶。

堆排序3.png

删除节点7，节点6成为新堆顶。

堆排序4.png

删除节点6，节点5成为新堆顶。

堆排序5.png

删除节点5，节点4成为新堆顶。

堆排序6.png

删除节点4，节点3成为堆顶。

堆排序7.png

删除节点3，节点2成为新堆顶。

堆排序8.png

到此为止，原本的最大二叉堆已经变成一个从小到大的有序集合。之前说过，二叉堆实际存储在数组中，数组中的元素排列如下。

堆排序9.png

由此，可以归纳出堆排序算法的步骤。

把无序数组构建成二叉堆。需要从小到大排序，则构建成最大堆；需要从大到小排序，则构建成最小堆。
循环删除堆顶元素，替换到二叉堆的末尾，调整堆产生新的堆顶。

堆排序的实现

整体代码

import java.util.Arrays;

/**
 * 描述：堆排序。
 * <p>
 * Create By ZhangBiao
 * 2020/5/25
 */
public class HeapSort {

    /**
     * 下沉调整
     *
     * @param arr         待调整的堆
     * @param parentIndex 要下沉的父节点
     * @param length      堆的有效大小
     */
    public static void downAdjust(int[] arr, int parentIndex, int length) {
        // temp保存父节点的值，用于最后的赋值
        int temp = arr[parentIndex];
        int childIndex = 2 * parentIndex + 1;
        while (childIndex < length) {
            // 如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子
            if (childIndex + 1 < length && arr[childIndex + 1] > arr[childIndex]) {
                childIndex++;
            }
            // 如果父节点大于任何一个孩子的值，则直接跳出
            if (temp >= arr[childIndex]) {
                break;
            }
            // 无须真正交换，单向赋值即可
            arr[parentIndex] = arr[childIndex];
            parentIndex = childIndex;
            childIndex = 2 * childIndex + 1;
        }
        arr[parentIndex] = temp;
    }

    /**
     * 堆排序（升序）
     *
     * @param arr 待调整的堆
     */
    public static void heapSort(int[] arr) {
        // 1、把无序数组构建成最大堆
        for (int i = (arr.length - 2) / 2; i >= 0; i--) {
            downAdjust(arr, i, arr.length);
        }
        System.out.println(Arrays.toString(arr));
        // 2、循环删除堆顶元素，移到集合尾部，调整堆顶产生新的堆顶
        for (int i = arr.length - 1; i > 0; i--) {
            // 最后1个元素和第1个元素进行交换
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            // 下沉调整最大堆
            downAdjust(arr, 0, i);
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 2, 6, 5, 7, 8, 9, 10, 0};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

二叉堆的节点，下沉调整是堆排序算法的基础，这个调节操作本身的时间复杂度是O(logn)。

我们再来回顾一下堆排序算法的步骤。

把无序数组构建成二叉堆。
循环删除堆顶元素，并将该元素移到集合尾部，调整堆产生新的堆顶。

第1步，把无序数组构建成二叉堆，这一步的时间复杂度是O(n)。

第2步，需要进行n-1次循环。每次循环调用一次downAdjust方法，所以第2步的计算规模是(n-1) * logn，时间复杂度为O(nlogn)。

两个步骤是并列关系，所以整体的时间复杂度是O(nlogn)。