力扣 23. 合并K个升序链表分冶+递归

Elvin域文

已于 2022-10-27 14:36:17 修改

阅读量212

点赞数 2

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

于 2022-10-27 14:35:09 首次发布

本文链接：https://blog.csdn.net/m0_51787573/article/details/127551669

版权

算法专栏收录该内容

31 篇文章 0 订阅

订阅专栏

第一站 LeetCode 新手村

前言

最近玩OJ赛，发现对算法的理解还需要更加扎实，code能力还可以进一步提升，所以做这样一个算法的系列文章，用于记录学习心得，交流经验，更好地进步和成长。

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

解题思路

预知

LeetCode是核心代码模式，所以只需要考虑核心算法，输入由系统自动完成，最后的输出以return返回；

思路

分冶，实现思路请参考代码注释

大佬有关递归的讲解视频放在下方，想深入了解的朋友们可以去看一下，很有精神！

8. 暴力递归_哔哩哔哩_bilibili

代码

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* mergeTwoLists(ListNode* list1, ListNode* list2){
        if(!list1) return list2;
        if(!list2) return list1;

        ListNode head, *tail=&head, *pre_list1=list1, *pre_list2=list2;
        while(pre_list1 and pre_list2){
            if(pre_list1->val < pre_list2->val){ //这里注意比较的是值要指向val  不可写成pre_list1 < pre_list2
                tail->next = pre_list1;
                pre_list1 = pre_list1->next;
            }else{
                tail->next = pre_list2;
                pre_list2 = pre_list2->next;
            }
            tail = tail->next;
        }
        tail->next = (pre_list1 ? pre_list1:pre_list2);   //这是因为最后可能有一个链表没有遍历完，在此处添加进来即可
        return head.next;
    }

    //在merge函数中实现我们的对半开 既然是对半开，那就需要递归的，到最深层，所以时间复杂度上会增加一些
    //用递归的原因就是要一直对半开，递的过程就是，一直二，二到空，二不下去了，开始归，一层一层往回退，
    ListNode* merge(vector<ListNode*>& lists,int l, int r) {
        if(l == r) return lists[l];
        if(l > r) return nullptr;
        int mid = (l+r) >> 1 ; //右移一位，相当于除2，mid代表对半开的位置，l是左边界，r是右边界
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid+1, r));
    }

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

};

看不懂两个链表合并原理的同学，可以参考这篇文章的注释

(1条消息) 力扣 23. 合并K个升序链表顺序合并_Elvin域文的博客-CSDN博客https://blog.csdn.net/m0_51787573/article/details/127549179?spm=1001.2014.3001.5502