数据结构之堆

堆的定义

“堆”通常指的是计算机科学中的一种数据结构，它是一棵完全二叉树，其中每个节点都有一个值，并且这些值具有一定的顺序关系。堆通常被用来实现优先队列，其中具有最高（或最低）优先级的元素始终位于堆的顶部。

在堆中，通常有两种常见的类型：最大堆（大根堆）和最小堆（小根堆）。在最大堆中，父节点的值始终大于或等于其子节点的值，而在最小堆中，父节点的值始终小于或等于其子节点的值。

在 Java 中优先队列默认情况下使用的是小根堆，本文以小根堆为例进行介绍，以下出现的堆均指小根堆。

堆通常用数组实现，其中父节点和子节点之间的关系通过数组索引来表示。这种实现方式使得堆的操作更加高效，并且可以在常数时间内访问堆的顶部元素。

堆的基本操作

1、调整

通过数组存储堆

public static final int MAXN = 100;
// heap为堆， n 为元素个数
int heap[] = new int[MAXN], n = 10;

由于堆要维持一种大小关系，故堆要不断进行调整，以下是堆的两种调整方式。

向下调整

将大值不断下沉到相应的位置

// 对 heap 数组在 [low, high] 范围进行向下调整
// 其中 low 为欲调整结点的数组下标， high 一般为堆的最后一个元素的数组下标
private void downAdjust(int low, int high) {
    // i 为调整结点， j 为其左孩子
    int i = low, j = i * 2;
    // 存在孩子结点
    while (j <= high) {
        // 如果右孩子存在，且右孩子的值小于左孩子
        if (j + 1 <= high && heap[j + 1] < heap[j]) j = j + 1;  // 让 j 存储右孩子下标，确保 j 存储了最小孩子的下标
        // 如果的孩子的值小于欲调整结点 i 的值
        if (heap[j] < heap[i]) {
            // 交换孩子与欲调整结点的值，使得大值下沉
            int tmp = heap[j];
            heap[j] = heap[i];
            heap[i] = tmp;
            // 修改欲调整结点，使得小值上冒
            i = j;
            j = i * 2;
        } else break;   // 孩子结点值大于欲调整结点的值，调整结束
    }
}

向上调整

将小值不断上冒到相应的位置

// 对 heap 数组在 [low, high] 范围进行向上调整
// 其中 low 一般为堆的第一个元素的数组下标， high 为欲调整结点的数组下标
private void upAdjust(int low, int high) {
    // i 为调整结点， j 为其父亲结点
    int i = high, j = i / 2;
    // 父亲结点在堆中
    while (j >= low) {
        // 如果的父亲结点的值大于欲调整结点 i 的值
        if (heap[j] < heap[i]) {
            // 交换父亲结点与欲调整结点的值，使得小值上冒
            int tmp = heap[j];
            heap[j] = heap[i];
            heap[i] = tmp;
            // 修改欲调整结点，使得大值下沉
            i = j;
            j = i / 2;
        } else break;   // 父亲结点值小于欲调整结点的值，调整结束
    }
}

2、建堆

假设堆中元素为 n, 堆又是一棵完全二叉树, 由于完全二叉树的非叶子结点范围在 $[1,\frac{n}{2}]$, 那么便可从 $\frac{n}{2}$ 倒着枚举, 从而使得每个结点位置都根据大小关系得到调整

// 建堆
// 时间复杂度 O(n)
private void creatHeap() {
    for (int i = n / 2; i >= 1; i--) {
        downAdjust(i, n);
    }
}

3、删除堆顶元素

删除堆顶元素，只需将堆中最后一个元素覆盖掉第一个元素，并在逻辑上使得堆中元素减少，并重新调整结点位置即可

// 时间复杂度 O(log n)
private void deleteTop() {
    // 将最后一个元素覆盖堆顶元素，并让元素个数减 1
    heap[1] = heap[n--];
    // 向下调整堆顶元素
    downAdjust(1, n);
}

4、插入元素

在堆的末尾位置插入一个元素，需要调整该元素在堆中位置，并且将的堆的元素增 1 即可

由于该元素在末尾，大概率需要将该元素向上移动位置，故采用向上调整

// 时间复杂度 O(log n)
private void insert(int x) {
    // 将元素个数加 1， 然后将数组末位赋值为 x
    heap[++n] = x;
    // 向上调整新加入的元素
    upAdjust(1, n);
}

堆的具体使用

1、堆排序

记堆大小为 n，由于堆顶一定是堆中最大的元素，只要将其与堆中最后一个元素交换位置，这样就保证了序列中最后一个元素为最大，再进行 [1, n - 1] 向下调整，再重复上述便得到序列中第二大元素在倒数第二个位置，如此往复序列便有序了。

最终可得到一个降序序列

private void heapSort() {
        // 建堆
        creatHeap();
        // 倒着枚举，直到堆中只有一个元素
        for (int i = n; i > 1; i--) {
            // 交换 heap[i] 与堆顶
           int tmp = heap[i];
           heap[i] = heap[1];
           heap[1] = tmp;
           // 调整堆顶
           downAdjust(1, i - 1);
        }
    }

2、数据流中的第 K 大元素 (力扣)

题目描述

设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。

请实现 KthLargest 类：

• KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。
• int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。

示例：

输入：
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
输出：
[null, 4, 5, 5, 8, 8]

解释：
KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3);   // return 4
kthLargest.add(5);   // return 5
kthLargest.add(10);  // return 5
kthLargest.add(9);   // return 8
kthLargest.add(4);   // return 8

提示：

• 1 <= k <= 104
• 0 <= nums.length <= 104
• -104 <= nums[i] <= 104
• -104 <= val <= 104
• 最多调用 add 方法 104 次
• 题目数据保证，在查找第 k 大元素时，数组中至少有 k 个元素

题解

由于优先队列底层就是由堆实现的，直接使用优先队列即可

class KthLargest {

    private PriorityQueue<Integer> pq = new PriorityQueue<>();
    int k;

    public KthLargest(int k, int[] nums) {
        this.k = k;
        for (int num : nums) pq.add(num);
    }

    public int add(int val) {
        pq.offer(val);
        while (pq.size() > k) pq.poll();
        return pq.peek();
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest obj = new KthLargest(k, nums);
 * int param_1 = obj.add(val);
 */

堆的模板

public class MinHeap {
    int[] heap;
    int n;

    public MinHeap(int capacity) {
        heap = new int[capacity];
    }

    // 建堆
    private void creatHeap() {
        for (int i = (n >> 1) - 1; i >= 0; i--) {
            down(i);
        }
    }

    // 得到堆顶元素，并且将该元素出堆
    public int poll() {
        swap(0, n - 1);
        n--;
        down(0);
        return heap[n];
    }

    // 得到指定下标的堆中元素，并且将该元素出堆
    public int poll(int index) {
        swap(index, n - 1);
        n--;
        down(index);
        return heap[n];
    }

    // 得到堆顶元素，但该元素不出堆
    public int peek() {
        return heap[0];
    }

    // 插入元素
    public boolean offer(int offered) {
        if (n == heap.length) {
            return false;
        }
        up(offered);
        n++;
        return true;
    }

    // 堆中是否满了
    public boolean isFull() {
        return n == heap.length;
    }

    // 替换堆顶元素
    public void replace(int replaced) {
        heap[0] = replaced;
        down(0);
    }

    // 向上调整
    private void up(int offered) {
        int child = n;
        while (child > 0) {
            int parent = (child - 1) >> 1;
            if (offered < heap[parent]) {
                heap[child] = heap[parent];
            } else {
                break;
            }
            child = parent;
        }
        heap[child] = offered;
    }

    // 向下调整
    private void down(int parent) {
        int left = (parent << 1) + 1;
        int right = left + 1;
        int min = parent;
        if (left < n && heap[left] < heap[min]) {
            min = left;
        }
        if (right < n && heap[right] < heap[min]) {
            min = right;
        }
        if (min != parent) {
            swap(min, parent);
            down(min);
        }
    }

    // 交换两个索引处的元素
    private void swap(int i, int j) {
        int t = heap[i];
        heap[i] = heap[j];
        heap[j] = t;
    }
}