Leetcode.23 合并 K 个升序链表

最新推荐文章于 2024-11-01 15:19:21 发布

感觉画质不如…原神

最新推荐文章于 2024-11-01 15:19:21 发布

阅读量41

点赞数 1

分类专栏： Leetcode 文章标签：链表 leetcode

本文链接：https://blog.csdn.net/m0_74396439/article/details/130994026

版权

Leetcode 专栏收录该内容

441 篇文章 2 订阅

订阅专栏

文章介绍了如何在LeetCode上解决合并K个已排序链表的问题，提供了两种解法：一种是迭代方法，直接应用合并两个有序链表的思路，时间复杂度为O(k*(m+n))；另一种是分治和递归结合的方法，时间复杂度为O(k*n*logk)。C++代码实现也被展示出来。

摘要由CSDN通过智能技术生成

题目链接

Leetcode.23 合并 K 个升序链表 hard

题目描述

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

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

示例 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 == l i s t s . l e n g t h$
$0 <= k <= 10^4$
$0 <= l i s t s [i] . l e n g t h <= 500$
$10^4 <= lists[i][j] <= 10^4$
$l i s t s [i]$ 按升序排列
$l i s t s [i] . l e n g t h$ 的总和不超过 $10^4$

解法一：迭代 & 递归

我们直接使用 21.合并两个有序链表的代码

21.合并两个有序链表的代码题解

依次的合并 $k$ 个有序链表，最后直接返回即可。

时间复杂度： $\times (m + n))$ ， $m$ 和 $n$ 是合并的两个链表的长度

C++代码：

/**
 * 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){
        if(a == nullptr || b == nullptr){
            return a == nullptr ? b : a;
        }
        if(a->val <= b->val){
            a->next = merge(a->next,b);
            return a;
        }
        else{
            b->next = merge(a,b->next);
            return b;
        }
    }

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

解法二：分治 & 递归

时间复杂度： $\times n \times logk)$

C++代码：

/**
 * 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(int l,int r,vector<ListNode*> lists){
        if(l == r) return lists[l];
        int mid = (l + r) >> 1;
        ListNode* a = merge(l , mid , lists);
        ListNode* b = merge(mid + 1 , r , lists);
        return merge_list(a,b);
    }

    ListNode* merge_list(ListNode* a , ListNode* b){
        if(a == nullptr || b == nullptr){
            return a == nullptr ? b : a;
        }
        if(a->val <= b->val){
            a->next = merge_list(a->next,b);
            return a;
        }
        else{
            b->next = merge_list(a,b->next);
            return b;
        }
    }


    ListNode* mergeKLists(vector<ListNode*>& lists) {
       if(lists.size() == 0) return nullptr;
       int n = lists.size();
       return merge(0 , n - 1 ,lists);
    }
};