021.合并两个有序链表，递归和遍历

news2024/10/6 22:34:05

题意

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

难度

简单

示例

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

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

输入：l1 = [], l2 = [0]
输出：[0]
复制代码

分析 1

先来读题，关键词，两个升序链表，合并，一个新的升序链表。

既然升序过，那最小的数字肯定是两个链表l1和l2中头节点中的一个。

如果最小的是 l1 的头节点，那么第二小的节点肯定是l2的头节点或者l1.next，只要再比较一下两个的大小就能够得到第二小的节点。

如果最小的是 l2 的头节点，那么第二小的肯定是l1的头节点或者l2.next；

那我们就可以采用递归的方式：

if (l1.val < l2.val) {
	l1.next = mergeTwoLists(l1.next, l2);
	return l1;
} else {
	l2.next = mergeTwoLists(l1, l2.next);
	return l2;
}

如果 l1 的头节点小于 l2 的头节点，那么 l1 的 next 应该是 l1.next 或者 l2；

如果 l1 的头节点大于 l2 的头节点，那么 l2 的 next 应该是 l1 或者 l2.next；

每次递归调用都会返回当前两个链表头部较小的那个节点作为合并链表的当前节点。

递归的结束条件就是 l1 或者 l2 为空，那么返回另一个链表即可。因为如果其中一个链表为空，就意味着另一个链表已经是当前最终的排序链表了，我们可以直接返回非空链表作为合并后的链表。

// 如果 l1 为空，返回 l2
if (l1 == null) {
	return l2;
}
// 如果 l2 为空，返回 l1
if (l2 == null) {
	return l1;
}

OK，我们来看完整的题解：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 如果 l1 为空，返回 l2
        if (l1 == null) {
            return l2;
        }
        // 如果 l2 为空，返回 l1
        if (l2 == null) {
            return l1;
        }
        
        // 选择较小的节点，递归地合并剩余部分
        if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

递归的关键在于理解每一步递归调用都在做什么，以及递归何时结束。在这个问题中，每一步递归都在处理两个链表当前的头节点，并通过递归调用来处理剩下的节点。递归使得问题规模逐渐变小，直至达到简单的基本情况（一个链表为空），从而完成整个合并过程。

我们来看题解的效率：

分析 2

递归看起来简单，但对于新手来说，理解起来很痛苦，尤其是递归的调用栈，很深。。。深的脑子一片乱麻。

那我们换一种更直接的思路，直接遍历两个链表，依次比较两个链表的节点，将较小的节点放到新链表中。

然后移动指针，继续比较，直到其中一个链表为空，然后将另一个链表剩余的部分直接连接到新链表的末尾。

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 初始化哨兵节点
        ListNode sentinel = new ListNode(-1);
        // 初始化一个指针，最初指向哨兵节点
        ListNode prev = sentinel;
        
        // 当两个链表都不为空时，循环继续
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            // 移动prev指针
            prev = prev.next;
        }
        
        // 直接将非空链表剩余部分连接到新链表末尾
        prev.next = l1 == null ? l2 : l1;
        
        // 返回哨兵节点的下一个节点，即合并后链表的头节点
        return sentinel.next;
    }
}

/**
     * 用循环遍历的方式
     *
     * 直接遍历两个链表，依次比较两个链表的节点，将较小的节点放到新链表中。
     *
     * 然后移动指针，继续比较，直到其中一个链表为空，然后将另一个链表剩余的部分直接连接到新链表的末尾。
     * @param l1
     * @param l2
     * @return
     */
    public ListNode mergeTwoLists2(ListNode l1 ,ListNode l2){
        //1初始化哨兵节点
        ListNode sentinel = new ListNode(-1);
        //2初始化一个指针，最初指向哨兵节点
        ListNode prev = sentinel;
        //3当两个链表不为空时，循环遍历两个链表,用prev连接后续节点
        while (l1 != null&& l2 != null ){
            //找最小节点开头
            if (l1.val <=l2.val){
                //指针 链表的下一个节点为 l1 头节点
                prev.next = l1;
                //更新 l1 链表的节点，变成后一个节点
                l1 = l1.next;
            }else {
                prev.next = l2;
                //后移
                l2 = l2.next;
            }
            //移动prev  。。指向  指针链表的 下一个节点 指向的为 刚才 拼接上的节点
            prev = prev.next;
        }
        //直接将非空链表剩余部分连接到新建表末尾
        prev.next = l1 ==null ? l2:l1;
        // 返回哨兵节点的下一个节点，即合并后链表的头节点
        return sentinel.next;
    }

这个题解的效率也非常不错，但更容易理解一些：