[每日一题] leetcode 23. 合并K个升序链表持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第7天，点击查看活动详情

23. 合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

思路

这道题是一道非常典型的题目了

我们先考虑它的简单版本：

合并 2 个链表

总所周知，合并两个链表的代码应该是不难的

大概样子就是一个双指针去合并

首先，定义一个辅助函数，用来添加一个元素到链表末尾

auto add = [](ListNode*& now, ListNode*& nex) -> void {
    now->next = nex;
    nex = nex->next;
    now = now->next;
};

其次，我们去依次的选取两个链表中当前比较下小的元素合并上去，注意，这里的链表要有序

while (a && b) add(cur, (a->val < b->val) ? a : b);

最后，记得合并完成后将另一个链表加入其中

if (a) add(cur, a);
if (b) add(cur, b);

好，合并两个链表的核心代码就这么点儿

那么，接下来，我们如何合并 n 个链表呢？

我们来分析一下顺序合并需要合并多少次

设链表为：

[1, 2, 3, 4, 5]
[6, 7, 8, 9, 10]
[11, 12, 13, 14, 15]
[16, 17, 18, 19, 20]

若是依次合并过来，我们所需要花费的时间是比较多的

假设每一个链表长度是k，一共n个链表，从第一个链表开始递增走的情况下 \\ 设最坏情况下，每次需要 length(list1) + length(list2) 次循环 \\ 需要的次数是 2\times k + 3\times k + 4\times k + ... n\times k \\ 化简得到：\\ k \times (\frac{(2+n)\times (n-1)}{2}) = k \times (\frac{n^2+n-2}{2})

ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode* now = nullptr;
    for (auto v : lists) 
        now = merge(now, v);
    return now;
}

嗯，可以大概分析出，我们的时间还是 $n^2$ 的时间的，对于我们这个题来说，这个世界复杂度虽然可以过，但是不够好

我们想一想，瓶颈在于何处？

每次都拿了一个比较大的链表去合并一个比较小的链表！

我们能不能逐步合并，意思是

设每一个链表长度为 x \\ 合并 长度为 x 和 x的时间是 2\times x \\ 假设现在有5个链表，我们采用如下方式合并: \\ 1 1 1 1 1 -> 2 2 1 -> 2 3 -> 5 \\ 每次将最小的两个合并的方式 \\ 或者换句话说，采用分治的方式 \\ 我们把 原来的组的个数分为 \frac{n}{2} 、\frac{n}{4}、\frac{n}{8}，... \\ 现在我们只需要考虑同组合并的问题了 \\ 设链表长度为 k，一共有 n 组 \\ 我们的时间复杂度是多少呢？ \\ 第一轮合并了 \frac{n}{2} 个组，总时间复杂度应该是 \lfloor\frac{n}{2}\rfloor \times 2\times k (想一想，为什么？) \\ 第二轮合并了 \frac{n}{4} 个组，总时间复杂度应该是 \lfloor\frac{n}{4}\rfloor \times 2\times (2 \times k) \\ 第三轮合并了 \frac{n}{8} 个组，总时间复杂度应该是 \lfloor\frac{n}{8}\rfloor \times 2 \times (2\times (2 \times k)) \\ ... （log_2 n \ 次） \\ 最坏的时间复杂度应该是 n \times k \times log_2n

ListNode* merge(int l, int r, vector<ListNode*>& lists) {
    if (l > r) return nullptr;
    if (l == r) return lists[l];
    int mid = l + r >> 1;
    return merge(merge(l, mid, lists), merge(mid + 1, r, lists));
}

代码


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* merge(ListNode* a, ListNode* b) {
        ListNode head;
        ListNode* cur = &head;
        auto add = [](ListNode*& now, ListNode*& nex) -> void {
            now->next = nex;
            nex = nex->next;
            now = now->next;
        };
        while (a && b) add(cur, (a->val < b->val) ? a : b);
        if (a) add(cur, a);
        if (b) add(cur, b);
        return head.next;
    }
    ListNode* merge(int l, int r, vector<ListNode*>& lists) {
        if (l > r) return nullptr;
        if (l == r) return lists[l];
        int mid = l + r >> 1;
        return merge(merge(l, mid, lists), merge(mid + 1, r, lists));
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(0, lists.size()-1, lists);
    }
};