[Leetcode]21. 合并两个有序链表

Leetcode 21合并两个有序链表 咕咕咕,之前忙着看Django,又咕了leetcode好多天,今天开始每天一题leetcode加题解启动(发出了不咕咕咕的叫声 今天的题目是这样的 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 题意清晰,是一道... 阅读详情

一、题目描述

难度:简单
描述:
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1:
21题示例

输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]

示例 2:

输入:l1 = [], l2 = []
输出:[]

示例 3:

输入:l1 = [], l2 = [0]
输出:[0]

提示:

  • 两个链表的节点数目范围是 [0, 50]
  • -100 <= Node.val <= 100
  • l1 和 l2 均按 非递减顺序 排列

二、分析过程

链地址迭代法,尝试根据已有的知识和记忆实现的,主要思路是:新建一个链表用于存储合并后的链表,然后遍历两个链表,依次取其中数值较小的一个放入合并链表中,直到有一个链表为空,然后把另一个全部放入合并链表中。
需要注意到是:

  • 新建一个链表,需要再用一个链表记录他的头节点。
  • 合并链表往后追加数据,只能用next,不能直接赋新值,会断开链的
  • 当前节点赋值为它的下一个节点,实现指针的移动

详见题解过程。

三、题解过程

1.链地址迭代法

下面是根据自己的思路实现的代码:


//Definition for singly-linked list.
// public class ListNode {
//     int val;
//     ListNode next;
//     ListNode() {}
//     ListNode(int val) { this.val = val; }
//     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
//  }
 
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        //新建一个链表,需要再用一个链表记录他的头节点
        ListNode current = new ListNode(0);
        ListNode head = current;
        while(list1 != null && list2 != null){
            //往后追加数据,只能用next,不能直接赋新值,会断开链的
            if(list1.val < list2.val){
                current.next = new ListNode(list1.val);
                list1 = list1.next;
            }else{
                current.next = new ListNode(list2.val);
                list2 = list2.next;
            }
            //当前节点赋值为它的下一个节点,实现指针的移动
            current = current.next;
        }
        if(list1 == null && list2 != null){
            current.next = list2;
        }
        if(list1 != null && list2 == null){
            current.next = list1;
        }
        return head.next;
    }
}

2.迭代法(官方)

其实思路跟上一个方法相同,实现上有所优化,这里有详细的解题思路,不需要的可跳过看递归法。

思路

我们可以用迭代的方法来实现上述算法。当 l1 和 l2 都不是空链表时,判断 l1 和 l2 哪一个链表的头节点的值更小,将较小值的节点添加到结果里,当一个节点被添加到结果里之后,将对应链表中的节点向后移一位。

算法

  • 首先,我们设定一个哨兵节点 prehead ,这可以在最后让我们比较容易地返回合并后的链表。我们维护一个 prev 指针,我们需要做的是调整它的 next 指针。

  • 然后,我们重复以下过程,直到 l1 或者 l2 指向了 null :如果 l1 当前节点的值小于等于 l2 ,我们就把 l1 当前的节点接在 prev 节点的后面同时将 l1 指针往后移一位。否则,我们对 l2 做同样的操作。不管我们将哪一个元素接在了后面,我们都需要把 prev 向后移一位。

  • 在循环终止的时候, l1 和 l2 至多有一个是非空的。由于输入的两个链表都是有序的,所以不管哪个链表是非空的,它包含的所有元素都比前面已经合并链表中的所有元素都要大。这意味着我们只需要简单地将非空链表接在合并链表的后面,并返回合并链表即可。


//Definition for singly-linked list.
// public class ListNode {
//     int val;
//     ListNode next;
//     ListNode() {}
//     ListNode(int val) { this.val = val; }
//     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
//  }
 
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        //新建一个链表,需要再用一个链表记录他的头节点
        ListNode current = new ListNode(0);
        ListNode head = current;
        while(list1 != null && list2 != null){
            //往后追加数据,只能用next,不能直接赋新值,会断开链的
            if(list1.val < list2.val){
                current.next = list1;
                list1 = list1.next;
            }else{
                current.next = list2;
                list2 = list2.next;
            }
            //当前节点赋值为它的下一个节点,实现指针的移动
            current = current.next;
        }
        // 合并后 list1 和 list2 最多只有一个还未被合并完,我们直接将链表末尾指向未合并完的链表即可
        current.next = list1 == null ? list2 : list1;

        return head.next;
    }
}

复杂度分析

  • 时间复杂度:O(n+m),其中 n 和 m 分别为两个链表的长度。因为每次循环迭代中,l1 和 l2 只有一个元素会被放进合并链表中, 因此 while 循环的次数不会超过两个链表的长度之和。所有其他操作的时间复杂度都是常数级别的,因此总的时间复杂度为 O(n+m)。

  • 空间复杂度:O(1)。我们只需要常数的空间存放若干变量。

2.递归法

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

复杂度分析

  • 时间复杂度:O(n+m),其中 n 和 m 分别为两个链表的长度。因为每次调用递归都会去掉 l1 或者 l2 的头节点(直到至少有一个链表为空),函数 mergeTwoList 至多只会递归调用每个节点一次。因此,时间复杂度取决于合并后的链表长度,即 O(n+m)。

  • 空间复杂度:O(n+m),其中 n 和 m 分别为两个链表的长度。递归调用 mergeTwoLists 函数时需要消耗栈空间,栈空间的大小取决于递归调用的深度。结束递归调用时 mergeTwoLists 函数最多调用 n+mn+m 次,因此空间复杂度为 O(n+m)。

工业质检实战:如何用MVTec AD数据集训练你的第一个无监督异常检测模型 本文提供了一份基于MVTec AD数据集的工业质检实战指南,详细介绍了如何从零开始训练一个无监督异常检测模型。内容涵盖数据预处理、模型架构选型(如CAE、GAN与特征字典方法)、特征提取、损失函数设计以及关键的阈值确定与后处理流程,旨在帮助工程师快速掌握将AI技术落地于实际产线质检的核心步骤与调参经验。 阅读详情

相关推荐

SLF4J StaticLoggerBinder报错全解析:从依赖冲突到类加载的根治方案

在Java应用开发中,日志系统是监控、调试和问题排查的核心基础设施。SLF4J作为日志门面(Facade),通过统一的API接口实现了业务代码与具体日志实现(如Logback、Log4j2)的解耦,其工作原理依赖于运行时在类路径上查找并绑定具体的日志实现。当出现“Failed to load class org.slf4j.impl.StaticLoggerBinder”错误时,意味着SLF4J无法完成这一关键绑定,导致日志功能静默失效,这在依赖管理复杂的微服务架构和持续集成环境中尤为常见。该问题的技术价值

weixin_30892889的博客 462

【刷题之路】LeetCode 21. 合并两个有序链表

空间复杂度:O(m+n),m和n分别为两个链表的长度,空间复杂度递归调用的层数,最坏情况下,对于两个链表的每个节点我们都要调用一次,因此空间复杂度为O(m+n)。所以我们可以将思路转化为,每次调用只需要选出较小的节点然后让较小的节点连接上后面合并后的链表即可,而后面的链表的合并也是用同样的递归方式来完成。其实从上面的解法中我们也能得到启发想出一个大事化小的解法,因为我们每次的遍历只需要选出一个较小的节点,然后尾插到新链表之中。时间复杂度:O(m+n),其中m和n分别为两个链表的长度。

kk702392702的博客 1143

5分钟搞定!用FunASR在本地快速部署达摩院Paraformer语音识别模型

本文提供了一份快速部署指南,教你如何在5分钟内利用FunASR工具包在本地电脑上启动达摩院Paraformer语音识别模型。Paraformer作为一款非自回归端到端模型,以其推理速度快、识别精度高的特点,结合FunASR的一键式模型加载和统一API,让开发者能轻松构建本地语音识别系统,极大降低了前沿AI技术的应用门槛。

q9w8e7r6t5的博客 608

将N条长度均为M的有序链表进行合并,合并以后的链表也保持有序,时间复杂度为()?

1. 在每一个链表中取出第一个值,然后把它们放在一个大小为N的数组里,然后把这个数组当成heap建成小(大)根堆。此步骤的时间复杂度为O(N):N个数构建一个堆的复杂度是O(N) 2. 取出堆中的最小值(也是数组的第一个值), 然后把该最小值所处的链表的下一个值放在数组的第一个位置。如果链表中有一个已经为空(元素已经都被取出),则改变heap的大小。此步骤的时间复杂度为O(lg N)。...

zz2230633069的博客 3816

ad23新版Geber导出-官方教程(22.11版本后)

AD23新版本geber文件导出(含官方教程)-22.11之后的版本均可用此教程

安和的博客 3万+

实战分享:如何用Dify和MaxKb实现文档智能切分与高效检索(附代码解析)

本文详细介绍了如何结合Dify和MaxKB构建文档智能切分与高效检索系统。针对传统全文检索的不足,提出了结构感知的文档切分方案,通过解析文档层级关系并构建标题链,实现了精准的章节级检索。文章包含完整的代码实现,涵盖文档解析、智能切分、向量化策略及双索引优化,并分享了性能调优和生产环境实践经验。

qsc90123456的博客 547

合并两个链表

合并两个链表 题目描述: 思路一:迭代 我们可以用迭代的方法来实现上述算法。当 l1 和 l2 都不是空链表时,判断 l1 和 l2 哪一个链表的头节点的值更小,将较小值的节点添加到结果里,当一个节点被添加到结果里之后,将对应链表中的节点向后移一位 首先,我们设定一个哨兵节点 prehead ,这可以在最后让我们比较容易地返回合并后的链表。我们维护一个 prev 指针,我们需要做的是调整它的 next 指针。然后,我们重复以下过程,直到 l1 或者 l2 指向了 null :如果 l1 当前节点的值小于

weixin_43831728的博客 3877

Vivado2022.2下载安装

链接:https://pan.baidu.com/s/1lyfE2d-VmaWC-_aR8ratCQ提取码:mt09。

weixin_61081689的博客 2万+

链表:21. 合并两个有序链表

21. 合并两个有序链表 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1: 输入:list1 = [1,2,4], list2 = [1,3,4] 输出:[1,1,2,3,4,4] 示例 2: 输入:list1 = [], list2 = [] 输出:[] 示例 3: 输入:list1 = [], list2 = [0] 输出:[0] 提示: 两个链表的节点数目范围是 [0, 50] -100 <= Node.

曾小二的博客 4716

Unity URP半透明物体深度排序优化:解决自交叠渲染瑕疵

本文深入探讨了Unity URP管线中半透明物体深度排序的优化方法,重点解决自交叠区域的渲染瑕疵问题。通过双通道渲染、深度预写入、多通道渲染等核心技术,结合实战案例和性能数据,帮助开发者实现高质量的透明效果渲染。

weixin_30879169的博客 422

对CryptoDriver里密钥格式定义的探索(1)

一入网络安全才发现深似海,传统汽车MCU码农转型之路异常艰难。在CP AUTOSAR中的CryptoDriver SWS对密钥格式的需求来源于RFC,其中要求了RSA、ECC、SHE等key material的格式。再往下看,我就有些迷糊了,例如关于RSA Private Key的OCTEE STRING格式根据IETF RFC8017,Public Key又得根据RFC5280,完全不得其解。所以今天先从生成密钥对,并对其进行解析开始,一步一步拆解。

认真搞搞汽车MCU 531

21 合并两个有序链表

1,采用双指针。 使用带哨兵的头结点dummy,将合并之后的新链表链接在后面。 (1)设置一个cur指针指向合并后链表的尾结点。 (2)将list1和list2指向的值进行比较。 (3)如果list1的值<=list2的值,就将l1的节点链在哨兵节点的后面,然后list1=list1->next,cur=cur->next; (4)如果l1的值>l2的值,就将l2的节点链在哨兵节点的后面,然后list2=list2->next,cur=cur->...

weixin_52122624的博客 331

华为od 面试八股文_操作系统_01_含答案

华为od 面试八股文_操作系统_01_含答案

MISAYAONE的博客 3277

LeetCode 21. 合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

一起加油 5575

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

【力扣LeetCode】21 合并两个有序链表

题目描述(难度易) 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 链接 https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/ 思路...

Jiewang的博客 249

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

leetcode力扣21题合并两个有序链表

【代码】leetcode力扣21题合并两个有序链表。

xiaohao0001abc的博客 170

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

LeetCode 21:合并两个有序链表

目录LeetCode 21:合并两个有序链表题目描述解题迭代递归 LeetCode 21:合并两个有序链表 题目描述 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 【示例】 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 【难度】 简单 解题 【思路】     两个链表都是有序的,所以要完成的就是在对两个链表遍历的过程中,根据当前节点的大小,对节点进行断开和链接。 迭代

s_Shune 422

LeetCode(力扣) 21.合并两个有序链表

升序合并两个链表的递归与迭代解法

2302_76866243的博客 444

力扣-21.合并两个有序链表

小结:注意题目中的链表没有头结点,边界问题。

weixin_46878941的博客 470

《LeetCode力扣练习》第21题 合并两个有序链表 Java

《LeetCode力扣练习》第21题 合并两个有序链表 Java 一、资源 题目: 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1: 输入:l1 = [1,2,4], l2 = [1,3,4] 输出:[1,1,2,3,4,4] 示例 2: 输入:l1 = [], l2 = [] 输出:[] 示例 3: 输入:l1 = [], l2 = [0] 输出:[0] 提示: 两个链表的节点数目范围是 [0, 50] -100 <= Node.

XRT_knives的博客 268

递归-21.合并两个有序链表-力扣(LeetCode)

个人主页:1白天的黑夜1-优快云博客专栏:力扣刷题录_1白天的黑夜1的博客-优快云博客、企鹅程序员:Linux 系统与网络编程_1白天的黑夜1的博客-优快云博客目录一、题目解析1、合并两个有序链表2、新链表节点是由给定两个链表拼接而成的二、算法原理解法:递归如何写递归代码?1、重复的子问题->函数头设计2、只关心某一个子问题做什么->设计函数体3、递归的出口对于链表类的题,还是建议多画图,去体会链接的过程,题目链接放在下面,可以去动手敲敲三、代码示例四、递归展开图看到最后,如果对您有所帮助,还请点赞、

black_bear_white的博客 1327

LeetCode:21. 合并两个有序链表(python)

LeetCode:21. 合并两个有序链表(python) 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 LeetCode 链接 思路: 迭代,遍历两个链表,比较两个节点值,指向较小值节点 递归,比较链表...

wk的博客 1070

力扣LeetCode第21题合并两个有序链表

力扣第21题合并两个有序链表

weixin_44061444的博客 1573

力扣(LeetCode)21. 合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 思路:难点在于这是无头节点的链表,所以要首先找出头节点较小的链表标记为Min,另一个标记为Max,这样就对Max进行遍历,如果Max的值大于等于Min当前的值且小于...

Pwnpanda的博客 406

Leetcode 21 有序链表合并【python】

Leetcode 21 有序链表合并题目描述代码解题思路 题目描述 Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. Example Input: 1->2-...

Emelia_的博客 154

21. 合并两个有序链表 - 力扣(LeetCode)

这个思路的关键在于利用两个指针来同时遍历两个链表,通过比较节点值来决定哪个节点应该被添加到新链表中。同时,通过哑节点来简化链表的头节点操作。来遍历两个链表,并通过比较它们的值来决定哪个节点应该被添加到新链表中。最后,如果其中一个链表还有剩余节点,我们直接将它们连接到新链表的末尾。最后,我们返回哑节点的下一个节点,它实际上是新链表的头节点。新链表是通过拼接给定的两个链表的所有节点组成的。,并将它们合并为一个新的链表,然后打印出合并后的链表的值。在示例代码中,我们创建了两个示例链表。类来表示链表节点,并在。

it爱好者的学习之路 2801
上一篇: 解决Win10磁盘占用100%
下一篇: Java中几个特殊的运算符
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值