【算法与数据结构】堆排序

排序步骤

1. 将长度为n的数组转化为大小顶堆
2. 将第一个数沉底到最后
3. 维护剩余数字的大小顶堆
4. 重复 2 3 步n-1次

代码

转化顶堆代码

    /**
     * @param arr   维护的数组
     * @param root  开始维护的根节点
     * @param length    需要维护的长度
     */
    public static void adjustHeap(int[] arr, int root, int length){

        // 1.临时存储需要调整的数
        int temp = arr[root];

        // 2.因为堆不区分左右子节点的大小，所以可以延一条路径下去
        for (int i = root*2+1; i < length; i = i*2+1) {
            // 3.比较左右子节点，选择大的赋值给父节点
            if(i+1 < length && arr[i] < arr[i+1]){
                i++;
            }

            if(temp < arr[i]){
                arr[root] = arr[i];
                // 4.将子节点作为父节点循环
                root = i;
            }else{
                // 因为堆排序第一步由下到上，由右到左进行了大小顶堆的转化，所以可以保证子树皆为大小顶堆，直接退出循环
                break;
            }
        }
        arr[root] = temp;
    }

排序代码

    public static void sort(int[] arr){
        /**
         *  1.先转化为大小顶堆，从最后一个非叶子节点开始 
         *  (n-1)/2 = (arr.length-1-1)/2 = arr.length/2 - 1
         */
        for (int i = arr.length/2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }

        // 2.将arr[0]每次与最后一位交换，然后维护顶堆，共需n-1次
        int temp;
        for (int i = arr.length-1; i > 0; i--) {
            temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            adjustHeap(arr, 0, i);
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

测试

    @org.junit.jupiter.api.Test
    public void testHeap(){
        int[] array = {4, 1, 3, 6, 8, 1};
        HeapSort.sort(array);
    }

结果

注意

1. 堆排序时间复杂度在创建堆时为O(n)，排序时为O(nlogn)（需要排序n-1个，每次在堆中寻找一个位置，即logn）
2. 堆排序为不稳定排序