优先队列与二叉堆：从核心原理到堆排序与Top K实战

1. 为什么所有排序算法书都要讲优先队列

老实说，我啃《Algorithms_4th》前几章的时候，一直觉得优先队列就是个“高级点的队列”，直到我真正用它解决了一个实际需求才意识到，这东西的价值远不止“能弹出最大值”这么简单。第2.4节放在排序章节里，不是为了让你多记一种数据结构，而是在为堆排序、图的最短路径、事件驱动模拟这些大杀器铺垫地基。

优先队列（Priority Queue）的核心能力就两条：插入元素和删除最大（或最小）元素。听起来平平无奇？但你想想，如果有一个场景需要你反复从一堆数据里取“当前最重要”的那个，而且数据还在不停增加，你怎么办？线性扫描的复杂度是O(n)，每取一次都要全量遍历，数据量一上来立刻爆炸。

这就是优先队列存在的意义：它把“取最值”这件事的均摊复杂度压到了O(log n)，插入也是O(log n)。在《Algorithms_4th》第2.4节的语境里，作者用二叉堆实现了优先队列，然后紧接着用它漂亮地实现了堆排序。我当初看完最大的感触是：原来“排序”和“动态取最值”本质上是一回事，只是视角不同。

这篇文章我打算按自己的学习路径来写：先讲清楚优先队列要解决什么问题，再拆解二叉堆这个核心数据结构，然后用C++和Java各写一版可运行的实现，最后聊聊我在实际工程里踩过的坑。不管你是刚学到这节的学生，还是在刷题时被“Top K”问题折磨的开发者，这篇应该都能帮上忙。

1.1 优先队列到底解决了什么痛点

先抛一个非常生活化的例子。假设你在运营一个客服系统，用户不断提交工单，每个工单有优先级，高优先级的必须优先处理。如果用电销排队那种普通FIFO队列，VIP用户会被普通用户堵在后面，业务上完全不可接受。

用数组硬扛呢？每次取最高优先级工单都要遍历整个数组，工单一多就卡顿。用有序数组呢？插入时要搬移大量元素，维护成本同样吓人。

优先队列的巧妙之处在于，它不强求整个容器“全局有序”，只保证“堆顶是最大/最小”。为了维护这个弱序性质，付出的代价就是两个O(log n)的核心操作。这个“局部有序”的思路很关键，它比“全排序”便宜得多，却足以支撑绝大多数“动态取最值”的场景。

1.2 二叉堆：优先队列的经典落地方式

《Algorithms_4th》选用的底层实现是二叉堆（Binary Heap）。它的形态是一棵完全二叉树，并且满足“堆有序”性质：每个父节点的键值都大于等于（或小于等于）它的两个子节点。因为是完全二叉树，所以可以直接用数组存储，不需要指针，节点之间靠下标的算术关系就能定位。

用数组存完全二叉树有个非常优美的性质：假设根节点放在下标1（不是0），那么对于任意位置k的节点，它的父节点在下标k/2，左子节点在2k，右子节点在2k+1。这样，“找到父节点”和“找到子节点”都只是整数运算，连指针都省了，内存访问还特别友好。

我第一次看到这个设计时感慨了一句：数据结构的极致优雅往往就体现在这种“用下标代替指针”的灵光上。后面你会看到，堆排序、Dijkstra的优先队列优化，全都建立在这个简单约定上。

2. 核心操作拆解：上浮与下沉

优先队列的两个核心操作是插入和删除最大元素。它们的实现思路可以浓缩成两个词：上浮（swim）和下沉（sink）。理解这两个操作，整节内容就吃透了一半。

插入时，先把新元素追加到数组末尾（也就是堆的最后一个位置），然后让它“上浮”到合适的位置。删除最大时，把堆顶元素和末尾元素交换，删掉末尾，再让新的堆顶“下沉”到合适位置。这两个过程都只要沿着树的高度走，所以复杂度是O(log n)。

2.1 上浮操作：为什么新元素一定要从末尾“爬”上去

上浮操作要处理的场景很简单：一个节点的键值比它的父节点大，违反了堆有序。解决办法就是和父节点交换，然后继续向上比较，直到找到它该待的位置。

下面是Java风格的实现（《Algorithms_4th》原书的风格）：

java复制private void swim(int k) {
    while (k > 1 && less(k / 2, k)) {
        exch(k / 2, k);
        k = k / 2;
    }
}

这里的less(i, j)表示pq[i]是否小于pq[j]，exch(i, j)表示交换两个位置。你要注意一个细节：为什么插入时放在末尾而不是开头？因为末尾是“最后一个叶子节点”，它上面的整棵树已经满足堆有序了，此时只需要沿着一条路径向上调整，复杂度是树高，也就是O(log n)。如果你放在开头，可能会破坏多条路径的堆有序，那调整代价就不止O(log n)了。

注意：这里的下标k从1开始，所以在Java实现里，数组的第0个位置一般留空或存一个哨兵。这个习惯在《Algorithms_4th》里贯穿始终，后面我还会专门说下标问题。

2.2 下沉操作：删除后如何维持堆有序

删除最大元素时，我们不能直接把堆顶拿走，因为那会留下一个空洞，整棵树就不连续了。标准做法是：把堆顶和数组末尾元素交换，删除末尾（也就是原来的最大值），然后从新的堆顶开始下沉。

Java版本的sink如下：

java复制private void sink(int k) {
    while (2 * k <= N) {
        int j = 2 * k;
        if (j < N && less(j, j + 1)) j++;
        if (!less(k, j)) break;
        exch(k, j);
        k = j;
    }
}

这里有一个很隐蔽的细节：在比较父节点和子节点时，要先在左右两个子节点中选出较大的那个，然后再和父节点比较。为什么要选较大的？因为如果父节点比较大的子节点还大（或不小于），说明它已经比两个子节点都大，堆有序成立；如果父节点比较小的子节点小，那它未必比较大的小，直接交换可能让较大的子节点又违反堆有序。所以必须先找较大子节点，这是整个sink操作正确性的关键。

我当初写第一版时偷懒没找较大子节点，结果堆顶删除后总是差一位，后来打印堆结构才发现在这个细节上栽了跟头。

2.3 数组下标约定：0还是1，这是个问题

《Algorithms_4th》的Java代码统一用下标1作为根节点，下标0闲置。这样的好处是父子和下标的算术关系简单：父节点是k/2，子节点是2k和2k+1。如果用下标0作为根节点，那父节点是(k-1)/2，子节点是2k+1和2k+2，虽然也能写，但代码里到处是+1、-1，容易出错。

C++的std::priority_queue默认底层容器是vector，但它没有暴露堆的内部结构，你只能通过top()、push()、pop()操作。如果你想自己实现堆，我的建议是：自定义时也遵循下标1的约定，除非你有特殊需求。

在刷LeetCode的时候，很多时候你并不需要手写堆，直接用语言自带的数据结构就行。但理解下标约定有助于你调试自定义堆代码时快速定位问题。

3. 手写一个完整的优先队列

理论说完了，下面进入实操。我用C++和Java各写一版“手搓堆”实现的优先队列，不做任何封装依赖，方便你直接跑起来验证理解。

3.1 C++版本：从零实现最大堆优先队列

C++版我用vector<int>作为底层存储，下标0闲置，下标1开始存数据。为了贴近原书风格，我把比较器写死成“最大堆”，这样代码更直观。

cpp复制#include <iostream>
#include <vector>
#include <stdexcept>

using namespace std;

class MaxPQ {
private:
    vector<int> pq;   // pq[0] 不使用
    int N;            // 队列中元素个数

    bool less(int i, int j) {
        return pq[i] < pq[j];
    }

    void exch(int i, int j) {
        int t = pq[i];
        pq[i] = pq[j];
        pq[j] = t;
    }

    void swim(int k) {
        while (k > 1 && less(k / 2, k)) {
            exch(k / 2, k);
            k = k / 2;
        }
    }

    void sink(int k) {
        while (2 * k <= N) {
            int j = 2 * k;
            if (j < N && less(j, j + 1)) j++;
            if (!less(k, j)) break;
            exch(k, j);
            k = j;
        }
    }

public:
    MaxPQ() : N(0) {
        pq.push_back(0); // 占位
    }

    bool isEmpty() {
        return N == 0;
    }

    int size() {
        return N;
    }

    void insert(int v) {
        pq.push_back(v);
        N++;
        swim(N);
    }

    int delMax() {
        if (isEmpty()) throw runtime_error("Priority queue underflow");
        int max = pq[1];
        exch(1, N);
        pq.pop_back();
        N--;
        sink(1);
        return max;
    }

    int max() {
        if (isEmpty()) throw runtime_error("Priority queue underflow");
        return pq[1];
    }
};

测试代码很简单：

cpp复制int main() {
    MaxPQ pq;
    pq.insert(3);
    pq.insert(5);
    pq.insert(1);
    pq.insert(19);
    pq.insert(8);

    while (!pq.isEmpty()) {
        cout << pq.delMax() << " ";
    }
    cout << endl;
    return 0;
}

输出应该是：19 8 5 3 1。

3.2 Java版本：贴近原书的实现

如果你在学《Algorithms_4th》，Java版几乎是必看的。原书代码风格很简洁，我这里在保留逻辑的基础上补充了泛型和迭代器（这里迭代器我简化了，就放一个遍历方法）。

java复制public class MaxPQ<Key extends Comparable<Key>> {
    private Key[] pq;
    private int N;

    public MaxPQ(int capacity) {
        pq = (Key[]) new Comparable[capacity + 1];
    }

    public boolean isEmpty() {
        return N == 0;
    }

    public int size() {
        return N;
    }

    public void insert(Key v) {
        pq[++N] = v;
        swim(N);
    }

    public Key delMax() {
        Key max = pq[1];
        exch(1, N--);
        pq[N + 1] = null; // 防止对象游离
        sink(1);
        return max;
    }

    private void swim(int k) {
        while (k > 1 && less(k / 2, k)) {
            exch(k / 2, k);
            k = k / 2;
        }
    }

    private void sink(int k) {
        while (2 * k <= N) {
            int j = 2 * k;
            if (j < N && less(j, j + 1)) j++;
            if (!less(k, j)) break;
            exch(k, j);
            k = j;
        }
    }

    private boolean less(int i, int j) {
        return pq[i].compareTo(pq[j]) < 0;
    }

    private void exch(int i, int j) {
        Key t = pq[i];
        pq[i] = pq[j];
        pq[j] = t;
    }
}

一个Java特有的细节：delMax里，把堆顶和末尾交换后，要把pq[N+1]置为null。这不是强迫症，而是让GC能回收不再使用的对象引用，避免“对象游离”（loitering）。原书里专门提到过这一点，属于专业素养层面的细节。

3.3 插入和删除的时间复杂度分析

两个操作都沿着树的高度走。完全二叉树的高度是⌊log₂N⌋+1，所以：

• insert：追加到末尾是O(1)，swim最坏沿根路径走到底，O(log n)
• delMax：交换和删除是O(1)，sink最坏沿根路径走到底，O(log n)

但这个“最坏”到底有多坏？举个具体例子：插入一个比堆里所有元素都大的新元素，它会从叶子一路swim到根，路径长度等于树高。删除时，如果原末尾元素很小，它从根一路sink到叶子，路径长度同样等于树高。所以最坏情况都是O(log n)，均摊也是O(log n)。

如果我们维护的是有序数组，插入是O(n)（因为要搬移元素），删除是O(1)。优先队列的价值在于把插入从O(n)降到了O(log n)，代价是删除从O(1)升到了O(log n)。在“频繁插入+偶尔取最值”的动态场景中，这个交换绝对划算。

4. 从优先队列到堆排序，再到工程实战

当你掌握了一个能动态取最大值的结构后，一个自然延伸就是：把所有元素都插入，然后依次取出，不就排好序了吗？这就是堆排序的核心思路。在《Algorithms_4th》第2.4节的末尾，作者会顺手把这个推导过程给你展示一遍。

堆排序分两个阶段：堆构造和下沉排序。堆构造阶段，可以从左到右扫描数组用swim，也可以从右到左用sink（后者效率更高，因为叶子节点不需要下沉，可以跳过）。下沉排序阶段，反复把堆顶（最大值）和末尾交换，然后把堆的大小减一，再对新的堆顶做sink。

C++版堆排序核心代码：

cpp复制void sort(vector<int>& a) {
    int n = a.size();

    // 堆构造：从最后一个非叶子节点开始下沉
    for (int k = n / 2; k >= 1; k--) {
        sink(a, k, n);
    }

    // 下沉排序：不断把堆顶交换到末尾
    while (n > 1) {
        exch(a, 1, n--);
        sink(a, 1, n);
    }
}

注意下标处理，如果你用0-based数组，需要稍作换算。这里的sink函数需要接收“当前堆的有效大小”，否则会把已经排好序的末尾元素也纳入调整范围，造成排序结果错乱。

4.1 堆排序到底哪里强，哪里弱

先给结论：堆排序的时间复杂度是O(n log n)，空间复杂度是O(1)，没有额外数组开销。这三种性质组合在一起，让它成为“原地排序”里比较特别的存在。

但它的弱点也很明显：不稳定。如果两个元素的键值相同，排序后它们的相对位置可能会改变。为什么？因为堆构造和下沉排序过程中的交换操作，根本不关心键值相同的元素之间的相对顺序。对于要求稳定排序的场景（比如按时间排序后再按优先级排序），堆排序直接出局。

另外，堆排序的实际运行速度通常比快速排序慢。原因在于它访问内存的模式是“跳跃式”的，不是顺序访问，对CPU缓存不友好。快排是分段递归，局部性更好。所以工程上，绝大多数通用排序库用的是快排（或其变体，如C++的std::sort是内省排序），而不是堆排序。

4.2 堆排序的实际应用：优先队列替代排序

有一个场景我强烈建议用堆排序而不是全排序：Top K 问题。比如“在海量日志里找出现次数最多的10个IP”，如果全排序，需要维护一份全量数据的有序列表，内存可能是几十GB；但如果用一个容量为K的最小堆，每次只保留当前最大的K个，遍历一遍就能拿到答案，内存占用只有K。

为什么是最小堆？因为堆顶是当前K个里最小的那个，新元素只要比堆顶大，就替换堆顶并下沉，这样堆里始终是“全局最大的K个”。这个思路在实时流式计算里特别常用。

4.3 用好语言自带的优先队列

实际工程中，我很少手写堆。C++里有std::priority_queue，Java里有PriorityQueue，Python里有heapq。这些库实现久经考验，比我手搓的版本稳得多。

但要注意几个使用习惯：

C++的std::priority_queue默认是最大堆，取最大元素用top()，弹出用pop()。如果你想用最小堆，需要传std::greater<>作为比较器：

cpp复制#include <queue>
#include <vector>
#include <functional>

std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;

Java的PriorityQueue默认是最小堆，这一点和C++恰好相反，用的时候很容易踩坑。如果你想要最大堆，要传入Collections.reverseOrder()：

java复制PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());

如果你是在刷LeetCode，理解了底层原理后，直接用库函数就够了。但面太试的时候，面试官有时会问到底层实现，或者要求你手写堆。这时候光是“会用库”就不够了，必须能写出swim和sink。

5. 常见问题与排查技巧实录

写堆和用堆的过程中，我踩过不少坑。整理成一个速查表，希望能帮你跳过这些坑。

5.1 常见错误速查表

5.2 调试技巧：打印堆结构

堆是隐式的树结构，肉眼不好直接看。我调试堆相关代码时，最常用的方式是按层打印：

cpp复制void printHeap(const vector<int>& pq, int N) {
    int level = 1;
    for (int i = 1; i <= N; i++) {
        cout << pq[i] << " ";
        if (i == (1 << level) - 1) {
            cout << endl;
            level++;
        }
    }
    cout << endl;
}

这个技巧在排查“交换操作对不对”的时候特别好使。你每执行一步操作后，把堆结构打印出来，对照二叉堆的定义检查一遍，问题通常立刻暴露。

5.3 一个典型的调优场景

我曾经写过一个事件驱动模拟器，需要每秒处理上万个事件，每个事件有优先级和时间戳。一开始我用优先队列存“待处理事件”，理论上应该很高效，但实测性能就是上不去。

排查后发现两个问题：

一是比较器里写了很多逻辑，导致每次比较都触发对象的多个字段读取，开销很大。优化办法是：把“优先级”和“时间戳”打包成一个long型，高32位存优先级，低32位存时间戳，比较器只比较这个long值，性能立刻翻倍。

二是频繁的top()和pop()操作没有合并。很多场景下，我需要“看一眼堆顶，但不弹出去”。如果代码里在多个位置反复调用top()，库可能会重复计算堆顶，这个开销可以合并成一次调用，减少不必要的比较。

这两个优化做完，吞吐量提升了大概3倍。这说明一个道理：优先队列本身的复杂度虽然是O(log n)，但常数因子和比较器开销在真实场景里可能才是瓶颈。

6. 我个人实操中的体会

最后聊点学习心得。我当初学优先队列最大的障碍不是理解swim和sink，而是“为什么要用数组存树”这个思维转变。在我的旧认知里，树就该用节点和指针表示，数组存数组的。直到我亲手画了一棵堆的数组形态，才真正理解了“完全二叉树”这个前提的价值——它保证了数组中间不会出现空洞，所以下标算术才成立。

第二个体会是，优先队列不是“队列”。虽然名字里带着queue，但它和FIFO队列的行为完全不同。FIFO保证“先进先出”，优先队列保证“最大/最小先出”。如果你的业务明确需要“按到达顺序处理”，那用优先队列反而是错的。这一点别被名字误导。

第三个建议：如果你在学习《Algorithms_4th》，强烈建议把习题里的“多路归并”和“Top M”做一遍。这两道题是优先队列从“会用”到“理解本质”的分水岭。多路归并让我真正体会到“动态取最值”的威力，Top M则让我明白为什么堆可以在海量数据中只用O(k)空间拿到答案。

优先队列这个主题，看起来只是“一种数据结构”，但它其实是很多高级算法的黏合剂。把这个章节学扎实了，后面看Dijkstra、Huffman编码、事件驱动模拟，都会轻松很多。