数据结构与算法之美-10 堆 优先级队列

本文地址

---

目录

目录

• 目录
• 28 | 堆和堆排序：为什么说堆排序没有快速排序快？
  • 堆的概念
  • 如何存储一个堆
  • 堆上的主要操作
    • 堆化
    • 插入一个元素：从下往上的堆化
    • 删除堆顶元素：从上往下的堆化
      • 错误的方法
      • 正确的方法
  • 堆排序算法
    • 建大顶堆
      • 建堆图解
      • 建堆代码
      • 建堆的时间复杂度
    • 排序过程：循环堆化
  • 堆排序图解及代码
  • 堆排序性能分析
  • 为什么快速排序比堆排序性能好
• 29 | 堆的应用：如何快速获取到Top 10最热门的搜索关键词？
  • 堆的应用一：优先级队列
    • 合并有序小文件
      • 方案一：利用数组
      • 方案二：利用堆
    • 高性能定时器
  • 堆的应用二：利用堆求 Top K
    • 静态数据集
    • 动态数据集合
  • 堆的应用三：利用堆求中位数
    • 求动态数据集合中的中位数
    • 求百分位的数据
  • 解答开篇

28 | 堆和堆排序：为什么说堆排序没有快速排序快？

堆的概念

堆是一种特殊的树，只要满足下面这两点，它就是一个堆。

• 堆是一个完全二叉树
  • 完全二叉树要求，除了最后一层，其他层的节点个数都是满的，最后一层的节点都靠左排列
• 堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值
  • 等价于，堆中每个节点的值都大于等于（或者小于等于）其左右子节点的值
  • 每个节点的值都大于等于子树中每个节点值的堆，叫做“大顶堆”
  • 每个节点的值都小于等于子树中每个节点值的堆，叫做“小顶堆”

如何存储一个堆

完全二叉树比较适合用数组来存储，因为我们不需要存储左右子节点的指针，单纯地通过数组的下标，就可以找到一个节点的左右子节点和父节点。

数组中下标为 i 的节点的:

• 左子节点就是下标为 i∗2 的节点
• 右子节点就是下标为 i∗2 + 1 的节点
• 父节点就是下标为 i/2 的节点

堆上的主要操作

• 往堆中插入一个元素
• 获取、删除堆顶元素

堆化

往堆中插入一个元素或删除堆顶元素后，为了继续满足堆的两个特性，我们需要对堆进行调整，这个过程就叫做堆化（heapify）。

堆化实际上有两种，从下往上和从上往下。

堆化非常简单，就是顺着节点所在的路径，向上或者向下，对比，然后交换。

一个包含 n 个节点的完全二叉树，树的高度不会超过 logn。堆化的过程是顺着节点所在路径比较交换的，所以堆化的时间复杂度跟树的高度成正比，也就是 O(logn)。插入数据和删除堆顶元素的主要逻辑就是堆化，所以，往堆中插入一个元素和删除堆顶元素的时间复杂度都是 O(logn)。

插入一个元素：从下往上的堆化

我们让新插入的节点与父节点对比大小，如果不满足子节点小于等于父节点的大小关系，我们就互换两个节点。一直重复这个过程，直到父子节点之间满足刚说的那种大小关系。

public class Heap {
    private int[] a; // 数组，从下标1开始存储数据
    private int n;  // 堆可以存储的最大数据个数
    private int count; // 堆中已经存储的数据个数
    
    public Heap(int capacity) {
        a = new int[capacity + 1];
        n = capacity;
        count = 0;
    }
    
    public void insert(int data) {
        if (count >= n) return; // 堆满了
        ++count;
        a[count] = data;
        int i = count;
        while (i / 2 > 0 && a[i] > a[i / 2]) { // 自下往上堆化
            swap(a, i, i / 2); // 交换元素
            i = i / 2;
        }
    }
}

删除堆顶元素：从上往下的堆化

堆顶元素存储的就是堆中数据的最大值或者最小值。

错误的方法

假设我们构造的是大顶堆，堆顶元素就是最大的元素。当我们删除堆顶元素之后，就需要把第二大的元素放到堆顶，那第二大元素肯定会出现在左或右子节点中。然后我们再迭代地删除第二大节点，以此类推，直到叶子节点被删除。

不过这种方法有点问题，就是最后堆化出来的堆并不满足完全二叉树的特性。

正确的方法

实际上，我们稍微改变一下思路，就可以解决这个问题。

我们把最后一个节点放到堆顶，然后利用同样的父子节点对比方法。对于不满足父子节点大小关系的，互换两个节点，并且重复进行这个过程，直到父子节点之间满足大小关系为止。这就是从上往下的堆化方法。

因为我们移除的是数组中的最后一个元素，而在堆化的过程中，都是交换操作，不会出现数组中的“空洞”，所以这种方法堆化之后的结果，肯定满足完全二叉树的特性。

public void removeMax() {
    if (count == 0) return -1; // 堆中没有数据
    a[1] = a[count];
    --count;
    heapify(a, count, 1);
}

private void heapify(int[] a, int n, int i) { // 自上往下堆化
    while (true) {
        int maxPos = i;
        if (i * 2 <= n && a[i] < a[i * 2]) maxPos = i * 2;
        if (i * 2 + 1 <= n && a[maxPos] < a[i * 2 + 1]) maxPos = i * 2 + 1;
        if (maxPos == i) break;
        swap(a, i, maxPos);
        i = maxPos;
    }
}

堆排序算法

借助于堆这种数据结构实现的排序算法，就叫做堆排序。

这种排序方法的时间复杂度非常稳定，是 O(nlogn)，并且它还是原地排序算法。

建大顶堆

我们首先将数组原地建成一个大顶堆。所谓原地就是，不借助另一个数组，就在原数组上操作。

建堆的过程，有两种思路。

第一种是借助我们前面讲的，在堆中插入一个元素的思路。尽管数组中包含 n 个数据，但是我们可以假设，起初堆中只包含一个数据，就是下标为 1 的数据。然后，我们调用前面讲的插入操作，将下标从 2 到 n 的数据依次插入到堆中。这样我们就将包含 n 个数据的数组，组织成了堆。

第二种实现思路，跟第一种截然相反

• 第一种建堆思路的处理过程是，从前往后处理数组数据，并且每个数据插入堆中时，都是从下往上堆化
• 而第二种实现思路是，从后往前处理数组，并且每个数据都是从上往下堆化

因为叶子节点往下堆化只能自己跟自己比较，所以我们直接从最后一个非叶子节点开始，依次堆化就行了。

下标为 n/2 + 1 到 n 的节点是 叶子节点
下标为 1 到 n/2 的节点是 非叶子节点
下标为 n/2 的节点是 最后一个非叶子节点

建堆图解

建堆代码

private static void buildHeap(int[] a, int n) {
    for (int i = n / 2; i >= 1; --i) {
        heapify(a, n, i); //循环堆化
    }
}

private static void heapify(int[] a, int n, int i) {
    while (true) {
        int maxPos = i; //找左右子节点的最大节点
        if (i * 2 <= n && a[i] < a[i * 2]) maxPos = i * 2;
        if (i * 2 + 1 <= n && a[maxPos] < a[i * 2 + 1]) maxPos = i * 2 + 1;
        if (maxPos == i) break; //当前结点比左右子节点都大，不需要再找了
        swap(a, i, maxPos); //【当前结点】和【左右子节点的最大节点】交换
        i = maxPos; //对【交换后的结点】继续进行上述操作
    }
}

建堆的时间复杂度

堆排序的建堆过程的时间复杂度是 O(n)。

因为叶子节点不需要堆化，所以需要堆化的节点从倒数第二层开始。每个节点堆化的过程中，需要比较和交换的节点个数跟这个节点的高度 k 成正比。

每一层的节点个数和对应的高度如下图所示

将每一层的节点个数，乘以相应的高度，求和，就是算法时间复杂度：

把公式左右都乘以 2，就得到另一个公式 S2。我们将 S2 错位对齐，并且用 S2 减去 S1，可以得到 S：

S 的中间部分是一个等比数列，所以最后可以用等比数列的求和公式来计算：

因为 h = logn，代入公式 S，就能得到 S = O(n)，所以，建堆的时间复杂度就是 O(n)。

排序过程：循环堆化

建堆结束之后，数组中的数据已经是按照大顶堆的特性来组织的，数组中的第一个元素就是堆顶，也就是最大的元素。

• 我们把堆顶元素跟最后一个元素交换，那最大元素就放到了下标为 n 的位置
• 交换以后，我们将剩下的 n−1 个元素通过堆化的方法重新构建成大顶堆
• 重新堆化完成之后，我们再将堆顶元素跟下标是 n−1 的元素交换
• 重复这个过程，直到最后堆中只剩一个元素，排序工作就完成了

堆排序图解及代码

// n 表示数据的个数，数组 a 中的数据从下标 1 到 n 的位置
public static void sort(int[] a, int n) {
    buildHeap(a, n); //建大顶堆
    int k = n; //代表待排序元素总数
    while (k > 1) {
        swap(a, 1, k); //将堆顶元素和最后一个元素交换
        --k; //待排序元素总数减一
        heapify(a, k, 1); //将剩下的待排序元素通过堆化的方法，重新构建成大顶堆
    }
}

堆排序性能分析

• 空间复杂度：整个堆排序的过程，都只需要极个别临时存储空间，所以堆排序是原地排序算法。
• 时间复杂度：堆排序包括建堆和排序两个操作
  • 建堆过程的时间复杂度是 O(n)
  • 排序过程的时间复杂度是 O(nlogn)
  • 堆排序整体的时间复杂度是 O(nlogn)
• 稳定性：堆排序不是稳定的排序算法，因为在排序的过程，存在将堆的最后一个节点跟堆顶节点互换的操作，所以就有可能改变值相同数据的原始相对顺序。

为什么快速排序比堆排序性能好

堆排序是一种原地的、时间复杂度为 O(nlogn) 的排序算法。快速排序平均情况下的时间复杂度也为 O(nlogn)，甚至堆排序比快速排序的时间复杂度还要稳定。但是，在实际的软件开发中，快速排序的性能要比堆排序好，这是为什么呢？

主要有两方面的原因。

• 第一点，堆排序数据的访问方式没有快速排序友好

对于快速排序来说，数据是顺序访问的。而对于堆排序来说，数据是跳着访问的。

堆排序中，最重要的一个操作就是数据的堆化，对堆顶节点进行堆化，会依次访问数组下标是 1，2，4，8 的元素，而不是像快速排序那样，局部顺序访问，这样对 CPU 缓存 是不友好的。

• 第二点，对于同样的数据，在排序过程中，堆排序算法的数据交换次数要多于快速排序

对于基于比较的排序算法来说，整个排序过程就是由两个基本的操作组成的，比较和交换（或移动）。快速排序数据交换的次数不会比逆序度多。

但是堆排序的第一步是建堆，建堆的过程会打乱数据原有的相对先后顺序，导致原数据的有序度降低。比如，对于一组已经有序的数据来说，经过建堆之后，数据反而变得更无序了。

29 | 堆的应用：如何快速获取到Top 10最热门的搜索关键词？

堆的应用一：优先级队列

优先级队列首先应该是一个队列，队列最大的特性就是先进先出。但是，在优先级队列中，数据的出队顺序不是先进先出，而是按照优先级来，优先级最高的，最先出队

实现一个优先级队列的方法有很多，但是用堆来实现是最直接、最高效的。这是因为，堆和优先级队列非常相似。一个堆就可以看作一个优先级队列。很多时候，它们只是概念上的区分而已。

• 往优先级队列中插入一个元素，就相当于往堆中插入一个元素
• 从优先级队列中取出优先级最高的元素，就相当于取出堆顶元素

优先级队列的应用场景非常多，后面要讲的很多数据结构和算法都要依赖它。比如，赫夫曼编码、图的最短路径、最小生成树算法等等。

很多语言中都提供了优先级队列的实现，比如，Java 的 PriorityQueue，C++ 的 priority_queue 等。

合并有序小文件

假设我们有 k 个小文件，每个文件的大小是 100MB，每个文件中存储的都是有序的字符串。我们希望将这 k 个小文件合并成一个有序的大文件。

方案一：利用数组

我们从这 k 个文件中，各取第一个字符串，放入数组中，然后比较大小，把最小的那个字符串放入合并后的大文件中，并从数组中删除。

假设，这个最小的字符串来自于 m.txt 这个小文件，我们就再从这个小文件取下一个字符串，放到数组中，重新比较大小，并且选择最小的放入合并后的大文件，将它从数组中删除。依次类推，直到所有的文件中的数据都放入到大文件为止。

时间复杂度分析

• 假设每个小文件中有 n 个字符串，则需要遍历 k * n 次
• 每次遍历需要插入一个新元素，并对有序的 k 个字符串重新排序
  • 利用二分查找，查找插入位置时间复杂度为 logk
  • 插入新元素并移动后面的元素位置时间复杂度为 k
• 整体时间复杂度为 k * n * (logk + k) ≈ k^2 * n

方案二：利用堆

首先，每次从各个文件中拿出第一个字符串，然后将这 k 个字符串组成一个小顶堆。此时堆顶元素，也就是优先级队列队首的元素，就是最小的字符串，我们将这个字符串放入到大文件中，并将其从堆中删除。

假设，这个最小的字符串来自于 m.txt 这个小文件，我们就再从这个小文件取下一个字符串，放入到堆中。循环这个过程，就可以将 k 个小文件中的数据依次放入到大文件中。

时间复杂度分析

• 假设每个小文件中有 n 个字符串，则需要遍历 k * n 次
• 每次遍历需要往堆中插入一个新元素，并重新堆化，时间复杂度为常数 logk
• 整体时间复杂度为 k * n * logk ≈ klogk * n

比原来数组存储的方式高效了一些，具体高效多少取决于 k 的大小。

高性能定时器

假设我们有一个定时器，定时器中维护了很多定时任务，每个任务都设定了一个要触发执行的时间点。定时器每过一个很小的单位时间（比如 1 秒），就扫描一遍任务，看是否有任务到达设定的执行时间。如果到达了，就拿出来执行。

针对这个问题，我们就可以用优先级队列来解决。我们按照任务设定的执行时间，将这些任务存储在优先级队列中，队列首部（也就是小顶堆的堆顶）存储的是最先执行的任务。

这样，定时器就不需要每隔 1 秒就扫描一遍任务列表了。它拿队首任务的执行时间点，与当前时间点相减，得到一个时间间隔 T。

这个时间间隔 T 就是，从当前时间开始，需要等待多久，才会有第一个任务需要被执行。这样，定时器就可以设定在 T 秒之后，再来执行任务。从当前时间点到（T-1）秒这段时间里，定时器都不需要做任何事情。

当有新的任务插入时，先重新堆化，如果堆顶元素有变化，更新下定时器下次的查询时间即可

当 T 秒时间过去之后，定时器取优先级队列中队首的任务执行。然后再计算新的队首任务的执行时间点与当前时间点的差值，把这个值作为定时器执行下一个任务需要等待的时间。

这样，定时器既不用间隔 1 秒就轮询一次，也不用遍历整个任务列表，性能也就提高了。

堆的应用二：利用堆求 Top K

静态数据集

也就是说数据集合事先确定，不会再变。

• 我们先从数组中取出前 k 个元素，利用这些元素维护一个大小为 K 的小顶堆
• 然后顺序遍历数组，从数组中取出数据与堆顶元素比较
  • 如果比堆顶元素大，我们就把堆顶元素删除，并且将这个元素插入到堆中
  • 如果比堆顶元素小，则不做处理，继续遍历数组
• 这样等数组中的数据都遍历完之后，堆中的数据就是前 K 大数据了

遍历数组需要 O(n) 的时间复杂度，一次堆化操作需要 O(logK) 的时间复杂度，整体时间复杂度就是 O(nlogK)

动态数据集合

也就是说数据集合事先并不确定，有数据动态地加入到集合中。

实际上，我们可以一直都维护一个 K 大小的小顶堆，当有数据被添加到集合中时，我们就拿它与堆顶的元素对比。如果比堆顶元素大，我们就把堆顶元素删除，并且将这个元素插入到堆中；如果比堆顶元素小，则不做处理。这样，无论任何时候需要查询当前的前 K 大数据，我们都可以立刻返回给他。

堆的应用三：利用堆求中位数

中位数就是处在中间位置的那个数。

假设数据是从 0 开始编号的

• 如果数据的个数是奇数，把数据从小到大排列，那第 n/2 + 1 个数据就是中位数
• 如果数据的个数是偶数，那处于中间位置的数据有两个，第 n/2 个和第 n/2 + 1 个数据，这个时候，我们可以随意取一个作为中位数

求动态数据集合中的中位数

对于一组静态数据，中位数是固定的，我们可以先排序，第 n/2 个数据就是中位数。每次询问中位数的时候，我们直接返回这个固定的值就好了。所以，尽管排序的代价比较大，但是边际成本会很小。但是，如果我们面对的是动态数据集合，中位数在不停地变动，如果再用先排序的方法，每次询问中位数的时候，都要先进行排序，那效率就不高了。

借助堆这种数据结构，我们不用排序，就可以非常高效地实现求中位数操作。

我们需要维护两个堆，一个大顶堆，一个小顶堆。大顶堆中存储前半部分数据，小顶堆中存储后半部分数据，且小顶堆中的数据都大于大顶堆中的数据。

如果有 n 个数据，我们先从小到大排序，然后将前 n/2 + n%2 个数据存储在大顶堆中，后 n/2 个数据存储在小顶堆中。这样，大顶堆中的堆顶元素就是我们要找的中位数。

当新添加一个数据的时候，我们如何调整两个堆，让大顶堆中的堆顶元素继续是中位数呢？

• 如果新加入的数据小于等于大顶堆的堆顶元素，我们就将这个新数据插入到大顶堆；否则，我们就将这个新数据插入到小顶堆。
• 插入后，如果两个堆中的数据个数不符合前面的约定，我们可以将一个堆的堆顶元素移动到另一个堆中

于是，我们就可以利用一个大顶堆和一个小顶堆，实现在动态数据集合中求中位数的操作。

插入数据因为需要涉及堆化，所以时间复杂度为 O(logn)，但是求中位数我们只需要返回大顶堆的堆顶元素就可以了，所以整体时间复杂度就是O(logn)。

求百分位的数据

利用两个堆不仅可以快速求出中位数，还可以快速求其他百分位的数据，原理是类似的。

中位数的概念就是将数据从小到大排列，处于中间位置，就叫中位数，这个数据会大于等于前面 50% 的数据。99 百分位数的概念可以类比中位数，如果将一组数据从小到大排列，这个 99 百分位数就是大于前面 99% 数据的那个数据。

如果有 n 个数据，将数据从小到大排列之后，99 百分位数大约就是第 n * 99% 个数据。

假设当前总数据的个数是 n，我们维护两个堆，一个大顶堆，一个小顶堆。大顶堆中保存 n*99% 个数据，小顶堆中保存 n*1% 个数据。大顶堆堆顶的数据就是我们要找的 99% 响应时间。

每次插入一个数据的时候，我们要判断这个数据跟大顶堆和小顶堆堆顶数据的大小关系，然后决定插入到哪个堆中。如果这个新插入的数据比大顶堆的堆顶数据小，那就插入大顶堆，否则就插入小顶堆。

但是，为了保持大顶堆中的数据占 99%，小顶堆中的数据占 1%，在每次新插入数据之后，我们都要重新计算大顶堆和小顶堆中的数据个数是否还符合 99:1 这个比例。如果不符合，我们就将一个堆的堆顶数据移动到另一个堆，直到满足这个比例。

解答开篇

假设现在我们有一个包含 10 亿个搜索关键词的日志文件，如何快速获取到 Top 10 最热门的搜索关键词呢？

• 因为用户搜索的关键词，有很多可能都是重复的，所以我们首先要统计每个搜索关键词出现的频率。我们可以通过散列表来记录关键词及其出现的次数。
• 分片：10 亿条关键词太多，消耗的内存太大，需要先通过哈希算法分片到 10 个文件中
  • 我们先遍历这 10 亿个关键词，并且通过某个哈希算法对其求哈希值
  • 然后将哈希值同 10 取模，这样就可以将 10 亿条搜索关键词分片到 10 个文件中
  • 并且，相同的搜索关键词都会被分到同一个小文件中
• 散列表：我们顺序扫描每个包含 1 亿条搜索关键词的文件，当扫描到某个关键词时，先去散列表中查询
  • 如果存在，我们就将对应的次数 +1
  • 如果不存在，我们就将它插入到散列表，并记录次数为 1
  • 遍历完后，散列表中就存储了不重复的搜索关键词以及出现的次数
• 小顶堆：我们针对每个散列表，建立一个大小为 10 的小顶堆
  • 遍历散列表，依次取出每个搜索关键词及对应出现的次数，然后与堆顶的搜索关键词对比
  • 如果出现次数比堆顶搜索关键词的次数多，那就删除堆顶的关键词，将这个出现次数更多的关键词加入到堆中
  • 当遍历完整个散列表中的搜索关键词之后，堆中的搜索关键词就是当前散列表中出现次数最多的 Top 10 搜索关键词了
• 小顶堆：把这个 10 个 Top 10 放在一块，然后取这 100 个关键词中的 Top 10 个关键词即可

2021-09-03