21. 合并两个有序链表

题目链接

一、题目描述

1. 题目

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

2. 示例

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

示例 2：
输入：l1 = [], l2 = []
输出：[]

示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

3. 提示

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

二、代码实现

1. 递归

1.1 解题思路

链表、树、图相关的算法首先想递归。递归相关的知识见我的另一篇文章迭代与递归。

递归设计函数的步骤：
1. 找重复： 找到的相同的子问题。

如下图，可以得出子问题为，l1 和 l2 当前节点的不断比较，当然，这里的当前节点是需要不断变化的。

2. 找变化：聚焦于某一个子问题，查看变化的量，通常会作为参数，这时可定义函数体。

由于当前节点的比较是不断变化的，所以这里变化的量我们就需要分情况讨论了，如下图，可总结为小的往前走一步，继续跟大的比。

总结完情况，则进行代码实现：

public ListNode mergeTwoLists (ListNode listNode1, ListNode listNode2) {
     if(listNode1.val < listNode2.val){
         listNode1.next = mergeTwoLists(listNode1.next,listNode2);
         return  listNode1;
     }else {
         listNode2.next = mergeTwoLists(listNode1,listNode2.next);
         return  listNode2;
     }
 }

3. 找出口： 也就是找终止条件。

什么时候无法比较当前节点的值，这个比较好找，就是当 listNode1 的为 null，或者 listNode2 为 null 时，无法进行比较了，可直接返回对应有值的节点，代码如下。

 public ListNode mergeTwoLists (ListNode listNode1, ListNode listNode2) {
    if (listNode1 == null) {
        return listNode2;
    } else if (listNode2 == null) {
        return listNode1;
    } else if (listNode1.val < listNode2.val) {
        listNode1.next = mergeTwoLists(listNode1.next, listNode2);
        return listNode1;
    } else {
        listNode2.next = mergeTwoLists(listNode1, listNode2.next);
        return listNode2;
    }
}

1.2 复杂度分析

时间复杂度	O(m+n)，m、n 分别为链表的长度，因为每次调用递归都会去掉 listNode1 或者 listNode2 的头节点（直到至少有一个链表为空），则最多只会递归调用每个节点一次。因此，时间复杂度取决于合并后的链表长度，即 O(m+n)。
空间复杂度	O(m+n)，m、n 分别为链表的长度，递归需要消耗栈空间且大小取决于递归调用的深度。结束递归调用时最多调用 m+n 次，因此空间复杂度为 O(m+n)。

2. 迭代

2.1 解题思路

迭代与递归基本都是可以互转的，与递归类似，我们将两个链表的比较理解为指针的移动。

这里我们还需要一个哨兵节点，为什么需要哨兵节点呢，我们在遍历链表的过程中是不断的调整它的 next 指针，当我们遍历到最后时，哨兵节点更容易返回合并后的链表，过程如下图。

通过图解，可以了解迭代的大致流程，但是我们在 Java 代码实现时，还需要维护一个 prev 指针，用来调整它的 next 指针。

为什么需要这个指针而不是直接返回哨兵节点呢？原因是我们在不断的遍历中，指针会不断的下移，当我们合并完成所有的节点时，此时的指针是在最后，这时我们在获取合并后的链表就比较麻烦了。

而用一个 prev 指针代替哨兵节点去进行 next 指针的移动，当返回链表时，只需返回哨兵节点的 next 即可。

代码实现如下：

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
    
    // 哨兵节点的设置
    ListNode prehead = new ListNode(-1);

    // 维护 prev 指针进行移动
    ListNode prev = prehead;

    
    while (list1 != null && list2 != null) {
        // 值比较，小的接入哨兵节点，并往前走一步，继续与大的比较
        if (list1.val < list2.val) {
            prev.next = list1;
            list1 = list1.next;
        }
        else {
            prev.next = list2;
            list2 = list2.next;
        }
        
        // 指针移动到 next，为了后续的节点接入
        prev = prev.next;
    }

    // 三元运算，当 list1 或 list2 出现 null 时，非 null 的则可以直接接入哨兵节点
    prev.next = list1 != null ? list1 : list2;
    return prehead.next;
}

2.2 复杂度分析

时间复杂度	O(m+n)，m、n 分别为链表的长度，合并操作只需遍历链表。
空间复杂度	O(1)，prehead、prev 均只使用常数大小的内存空间。

posted @ 2024-06-13 09:40 fuxing．阅读(184) 评论(0) 编辑收藏举报

刷新页面返回顶部