合并 K 个升序链表

cpp 复制代码
class Solution {
public:
    // 主函数:负责启动分治过程
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 1. 如果列表为空,直接返回空(防止空数组报错)
        if (lists.empty()) return nullptr;
        // 2. 调用分治函数,范围从 0 到最后一个索引
        return solve(lists, 0, lists.size() - 1);
    }

private:
    // 分治函数:负责把 K 个链表不断二分
    ListNode* solve(vector<ListNode*>& lists, int l, int r) {
        // 3. 递归终止:如果区间里只有一个链表,直接返回它
        if (l == r) return lists[l];
        // 4. 计算中点,>> 1 相当于除以 2(位运算更快)
        int mid = (l + r) >> 1;
        // 5. 递归处理左边,递归处理右边,并把两边的结果通过 merge 函数合并
        return merge(solve(lists, l, mid), solve(lists, mid + 1, r));
    }

    // 核心合并函数:合并两个有序链表(递归版)
    ListNode* merge(ListNode* a, ListNode* b) {
        // 6. 如果 a 空了,返回 b;如果 b 空了,返回 a(谁不空回谁)
        if (!a || !b) return a ? a : b;

        // 7. 如果 a 节点的值比较小
        if (a->val < b->val) {
            // 8. 让 a 的下一个位置去接"剩下的节点合并后的结果"
            a->next = merge(a->next, b);
            // 9. 选了 a 作为当前最小,返回 a
            return a;
        } else {
            // 10. 如果 b 的值较小,同理让 b 的下一个位置去接合并结果
            b->next = merge(a, b->next);
            // 11. 选了 b 作为当前最小,返回 b
            return b;
        }
    }
};

假设我们的 lists 中有 4个小链表:

  • L0 : [1, 4]

  • L1 : [2, 6]

  • L2 : [0, 8]

  • L3 : [3, 7]


第一阶段:分治拆解 (solve 函数)

分治像一棵倒置的树,先把问题不断对半劈开。

  1. 第一层 :solve(0, 3)

    • 计算 mid = 1。

    • 拆分为左边 solve(0, 1) 和右边 solve(2, 3)。

  2. 第二层(左) :solve(0, 1)

    • 计算 mid = 0。

    • 拆分为 solve(0, 0)(直接返回 L0 )和 solve(1, 1)(直接返回 L1)。

  3. 第二层(右) :solve(2, 3)

    • 计算 mid = 2。

    • 拆分为 solve(2, 2)(直接返回 L2 )和 solve(3, 3)(直接返回 L3)。


第二阶段:递归合并 (merge 函数)

现在开始从底层向上"两两决斗"合并。

1. 合并 L0 1, 4 和 L1 2, 6
  • 比较 1 和 2 :1 小,选 1。1 的后面去接 merge(L0的4, L1的2)。

  • 比较 4 和 2 :2 小,选 2。2 的后面去接 merge(L0的4, L1的6)。

  • 比较 4 和 6 :4 小,选 4。4 的后面去接 merge(null, L1的6)。

  • 收尾:遇到 null,直接接上 6。

  • 结果 (La) :[1, 2, 4, 6]。

2. 合并 L2 0, 8 和 L3 3, 7
  • 同理,经过比较:0 < 3,3 < 7,7 < 8。

  • 结果 (Lb) :[0, 3, 7, 8]。


第三阶段:终极对决 (La 和 Lb 合并)

这是最后一步:merge(La, Lb),即合并 [1, 2, 4, 6] 和 [0, 3, 7, 8]。

  1. 比较 1 和 0 :0 胜出。结果链表:0 -> ...

  2. 比较 1 和 3 :1 胜出。结果链表:0 -> 1 -> ...

  3. 比较 2 和 3 :2 胜出。结果链表:0 -> 1 -> 2 -> ...

  4. 比较 4 和 3 :3 胜出。结果链表:0 -> 1 -> 2 -> 3 -> ...

  5. 比较 4 和 7 :4 胜出。结果链表:0 -> 1 -> 2 -> 3 -> 4 -> ...

  6. 比较 6 和 7 :6 胜出。结果链表:0 -> 1 -> 2 -> 3 -> 4 -> 6 -> ...

  7. 收尾 :La 已经空了,把 Lb 剩下的 [7, 8] 直接贴在后面。

最终冠军 :[0, 1, 2, 3, 4, 6, 7, 8]


总结这个过程的记忆点

  • Solve 是"向下扎根":直到看到单个链表。

  • Merge 是"向上开花":把拿到的两个链表像拉拉链一样合起来。

  • 递归的魅力:你不需要管中间有多少层,你只需要写好"两个怎么合",递归会自动帮你处理剩下的 K-2 个。

相关推荐
地平线开发者6 小时前
让 AI Agent 和 征程6 台架高效、稳定、安全地协作
算法·安全·自动驾驶
kyle~6 小时前
SHA-256 哈希去重
算法·哈希算法
风落青芜9 小时前
链式二叉树的实现与基本操作
c语言·开发语言·数据结构·算法
青少儿编程课堂10 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:中国剩余定理解析
c++·python·算法·bfs·信息学竞赛
罗西的思考1 天前
【轻量化复刻大模型 / KIMI K3】Muon 优化器及 训练系统
人工智能·算法·机器学习
ashiho1 天前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
数据工匠老o1 天前
数据库没死,业务卡住了:行锁等待、元数据锁、长事务的排查路径
数据库·算法·架构
黑客笔记1 天前
安全态势感知中的资产失陷排名思考
人工智能·算法·网络安全
青少儿编程课堂1 天前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:扫描线与线段树求矩形面积并解析
c++·python·算法·bfs·信息学竞赛