堆学习之旅第二篇-堆排序

「这是我参与2022首次更文挑战的第12天，活动详情查看：2022首次更文挑战」。

一、堆排序过程

• 数依次进，最终形成大根堆（把整个数组搞成大根堆），最终heapsize = N
• 把0位置的数（最大值）与 N - 1位置的数交换，最大值跑到了N - 1位置上，然后把最大值断掉（heapsize - 1）
• heapify调整堆结构，再次形成大根堆，此时0 ~ N - 2 范围内是大根堆
• 0 ~ N - 2 依次交换，周而复始...

二、实现

// 堆排序额外空间复杂度O(1)
public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
                return;
        }
        // O(N*logN)
//		for (int i = 0; i < arr.length; i++) { // O(N)
//			heapInsert(arr, i); // O(logN)
//		}
        // O(N)
        for (int i = arr.length - 1; i >= 0; i--) {
                heapify(arr, i, arr.length);
        }
        int heapSize = arr.length;
        swap(arr, 0, --heapSize);
        // O(N*logN)
        while (heapSize > 0) { // O(N)
                heapify(arr, 0, heapSize); // O(logN)
                swap(arr, 0, --heapSize); // O(1)
        }
}

// arr[index]刚来的数，往上
public static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
                swap(arr, index, (index - 1) / 2);
                index = (index - 1) / 2;
        }
}

// arr[index]位置的数，能否往下移动
public static void heapify(int[] arr, int index, int heapSize) {
        int left = index * 2 + 1; // 左孩子的下标
        while (left < heapSize) { // 下方还有孩子的时候
                // 两个孩子中，谁的值大，把下标给largest
                // 1）只有左孩子，left -> largest
                // 2) 同时有左孩子和右孩子，右孩子的值<= 左孩子的值，left -> largest
                // 3) 同时有左孩子和右孩子并且右孩子的值> 左孩子的值， right -> largest
                int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
                // 父和较大的孩子之间，谁的值大，把下标给largest
                largest = arr[largest] > arr[index] ? largest : index;
                if (largest == index) {
                        break;
                }
                swap(arr, largest, index);
                index = largest;
                left = index * 2 + 1;
        }
}

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

三、总结

建堆方法：上->下、下->上

• heapInsert：从上往下建堆，时间复杂度O(N * logN)，从下往上建堆，可以优化到O(N)

• heapify：时间复杂度O(N * logN)，没法优化了

• 堆排序可以只有heapify，没有heapInsert，因为heapInsert优化成了从下往上建堆了，而且堆排序，数据已经给好了。如果数据是一个一个的给，那heapInsert是不能省掉的

四、扩展

已知一个几乎有序的数组。几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k，并且k相对于数组长度来说是比较小的。

请选择一个合适的排序策略，对这个数组进行排序。

1.1、分析

假设k = 5，排完序后，因为每个元素移动的距离一定不超过K，也就是不能超过5，所以哪些位置的数能来到0位置，只有索引1~5之间的数能移动到0位置，5位置之后的数不可能来到0位置。

把0~5之间的数放到小根堆里，小根堆的大小为k + 1 = 6，弹出最小值放到数组0位置，接下来6位置的数进小根堆，弹出最小值放到1位置，把7位置的数进小根堆，弹出最小值放到2位置，依次类推...

时间复杂度O(N * logK)

1.2、实现

public static void sortedArrDistanceLessK(int[] arr, int k) {
        if (k == 0) {
                return;
        }
        // 默认小根堆
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        int index = 0;
        // 0...K-1
        for (; index <= Math.min(arr.length - 1, k - 1); index++) {
                heap.add(arr[index]);
        }
        int i = 0;
        for (; index < arr.length; i++, index++) {
                heap.add(arr[index]);
                arr[i] = heap.poll();
        }
        while (!heap.isEmpty()) {
                arr[i++] = heap.poll();
        }
}