排序算法之堆排序

堆的定义

堆实际上是一棵完全二叉树。分大顶堆和小顶堆
每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆
每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

算法
大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

如图

一般用数组来表示堆
根结点在角标0处
i结点的父结点下标就为(i-1)/2
i结点的左子结点下标为2*i+1
i结点的右子结点下标为2*i+2

如图

二叉树
所有的分支结点都存在左子树和右子树，并且所有的叶子结点都在同一层上称为满二叉树
除最后一层外，每一层上的结点数均达到最大值，且最后一层叶子结点一定集中在左部连续位置称为完全二叉树

如图

堆排序

堆排序是一种利用堆的性质的树形选择排序。

堆排序工作原理

第一步：构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)

第二步：将堆顶元素与末尾元素进行交换，使末尾元素最大。然后将剩余n-1个元素重新调整成一个大顶堆，再将堆顶元素与末尾元素交换，得到第二大元素…如此反复执行调整、交换，只到整个序列有序

堆排序实例步骤

第一步：建立无序序列初始堆结构图

第二步：从第一个非叶子结点从下至上，从右至左调整结构（第一个非叶子结点角标 arr.length/2-1=6/2-1=2，也就是下面角标为2的结点3）

因非叶子结点3只有一个叶子结点4，所以只需要比较3和4的大小，3<4则3与4进行位置交换，如图

第三步：再从倒数第二个非叶子结点从下至上，从右至左调整结构（倒数第二个非叶子结点角标 arr.length/2-1=6/2-1-1=1，也就是下面角标为1的结点7）

因非叶子结点7有两个叶子结点8、5。所以需要先比较8、5的大小，8>5然后再拿8与7比较，8>7则8与7进行位置交换，如图

第四步：再从倒数第三个非叶子结点从下至上，从右至左调整结构（倒数第三个非叶子结点角标 arr.length/2-1=6/2-1-1-1=0，也就是下面角标为0的结点2）

因非叶子结点2有两个叶子结点8、4。所以需要先比较8、4的大小，8>4然后再拿8与2比较，8>2则先跟新角标0的值为8，先临时记住2这个值，因角标1有两个叶子结点，所以角标1的值先不变，先比较出角标1的两个叶子结点较大值为7，再拿7与临时记住的2这个值比较，7>2所以最终2赋值到角标3上，7赋值到角标1上，如图

此时将一个无需序列构造成了一个大顶堆，即每个结点的值都大于或等于其左右孩子结点的值

第五步：将堆顶元素与末尾元素进行交换，使末尾元素最大，如图

第六步：将剩余n-1个元素重新调整成一个大顶堆，再将堆顶元素与末尾元素交换，得到第二大元素…如此反复执行调整、交换，只到整个序列有序，如图

Java代码

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = {2, 7, 3, 8, 5, 4};
        sort(arr);
        System.out.println("排序后结果是");
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int[] arr) {
        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr, i, arr.length);
        }

        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
            swap(arr, 0, j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr, 0, j);//重新对堆进行调整
            System.out.println(Arrays.toString(arr));
        }
    }

    /**
     * 调整大顶堆
     */
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];//先取出当前元素i
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {//从i结点的左子结点开始，也就是2i+1处开始
            //k+1<length 防止角标越界
            //arr[k]<arr[k+1] 如果左子结点小于右子结点，k指向右子结点
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                k++;
            }

            //如果子节点大于父节点，将子节点值赋给父节点（子节点值先不变，直到循环完毕后才赋值）
            if (arr[k] > temp) {
                arr[i] = arr[k];
                i = k;//记录最新最小坐标，用于交换值
            } else {
                break;
            }
        }
        arr[i] = temp;//i值已经变成k值，把最小值放到最下边
    }

    /**
     * 交换元素
     */
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

打印结果

[7, 5, 4, 2, 3, 8]
[5, 3, 4, 2, 7, 8]
[4, 3, 2, 5, 7, 8]
[3, 2, 4, 5, 7, 8]
[2, 3, 4, 5, 7, 8]
排序后结果是
[2, 3, 4, 5, 7, 8]

算法分析

时间复杂度
堆排序的时间复杂度为O(nlogn)。由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。

空间复杂度
堆排序仅需一个记录大小的供交换用的辅助存储空间。

稳定性
由于记录的比较与交换是跳跃式进行，因此堆排序是一种不稳定的排序算法。