堆与堆排序

1 大根堆与小根堆

1.1 介绍

1. 大根堆与小根堆必须是完全二叉树
2. 大根堆的父节点永远比子节点大或相等
3. 小根堆的父节点永远比子节点小或相等

本文皆以大根堆为例

1.2 PUSH

1. 尾部增加元素
2. 调整为大根堆：与父节点比对，若大于父节点则交换位置，直到小于等于父节点或没有父节点时停止

void push(int value) {
    if (isFull()) throw new RuntimeException("heap is full");
    heap[heapSize] = value;
    heapInsert(heap,heapSize++); // 插入一个元素后调整为大根堆
}

void heapInsert(int[] arr, int i) {
    while (arr[i] > arr[(i - 1) / 2]) {
        swap(arr, i, (i - 1) / 2);
        i = (i - 1) / 2;// (0-1)/2 == 0
    }
}

时间复杂度：O(logN) 空间复杂度：O(1)

1.3 POP

1. 根节点与尾节点交换，删除尾节点
2. 调整为大根堆：根节点与子节点比较，与比他大的最大子节点交换，直到无子节点比父子节点大，或孩子不存在时结束

int pop() {
    if (isEmpty()) throw new RuntimeException("heap is empty");
    swap(heap, 0, --heapSize); // 头尾交换，并删除
    heapify(heap, 0, heapSize); // 删除一个元素后，调整为大根堆
    return heap[heapSize];
}

void heapify(int[] arr, int index, int heapSize) {
    // 左右孩子pk，赢的和父节点交换
    // 直到不存在左右孩子，或左右孩子都比我小
    int left = index * 2 + 1;
    while (left < heapSize) {
        int win = arr[left+1] > arr[left] && left + 1 < heapSize ? left+1 : left;
        if (arr[win] <= arr[index]) {
            break; // 儿子都比父亲小
        }
        swap(arr, win, index);
        index = win;
        left = index * 2 + 1;
    }
}

时间复杂度：O(logN) 空间复杂度：O(1)

2 堆排序

2.1 标准堆排序

从上往下建堆

void heapSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) { // O(N)
        heapInsert(arr, i); // O(logN)
    }
    int heapSize = arr.length;
    while (heapSize > 0) { // O(N)
        heapify(arr, 0, heapSize); // O(logN)
        swap(arr, 0, --heapSize); // O(1)
    }
}

时间复杂度：O(NlogN)，空间复杂度：O(1)

2.2 改进版堆排序

从下往上建堆

void heapSort(int[] arr) {
    int heapSize = arr.length;
    for (int i = arr.length; i > 0; i--) {
        heapify(arr, i, heapSize); 
    }
    while (heapSize > 0) { // O(N)
        heapify(arr, 0, heapSize); // O(logN)
        swap(arr, 0, --heapSize); // O(1)
    }
}

时间复杂度：O(NlogN)，空间复杂度：O(1)

2.3 总结

改进版与标准版同为O(NlogN），到底快在哪儿？快在建堆

1. 标准版是从上往下建堆，O(NlogN)
   1. 第1层，1个节点，操作1次（看自己一眼，没法往上升）
   2. 第2层，2个节点，操作2次 （看自己一眼，上升1次）
   3. …
   4. 第n-2层，2^(n-3)个节点，操作n-2次（看自己一眼，上升n-3次）
   5. 第n-1层，2^(n-2)个节点，操作n-1次（看自己一眼，上升n-2次）
   6. 第n层，2^(n-1)个节点，操作n次（看自己一眼，上升n-1次）
2. 改进版是从下往上建堆，O(N)
   1. 第1层，1个节点，操作n次（看自己一眼，下沉n-1次）
   2. 第2层，2个节点，操作n-1次 （看自己一眼，下沉n-2次）
   3. …
   4. 第n-2层，2^(n-3)个节点，操作3次（看自己一眼，下沉2次）
   5. 第n-1层，2^(n-2)个节点，操作2次（看自己一眼，下沉1次）
   6. 第n层，2^(n-1)个节点，操作1次（看自己一眼，没子节点，没法沉）

堆其实就是个完全二叉树，那么最底层元素通常占了一半，于是越底层的交换成本越高，则整体建堆成本越高

3 相对有序的数组，移动元素个数不超过K

例：[2, 3, 1, 4, 6, 5, 9, 7, 8]，移动不超过3

解

1. 先搞一个k+1的小根堆，将k+1个元素push进去
2. 当数组还有元素时，每pop一个就往里push一个
3. 直到小根堆pop空

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