LeetCode刷题-链表21：合并有序链表

题目

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

示例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.val <= 100
• l1 和 l2 均按 非递减顺序 排列

解题思路

法一：递归法（执行用时：28ms，内存消耗：13MB）

函数在运行时调用自身，这个函数就叫递归函数，调用的过程就叫递归。

合并有序链表的整体思路就是每次比较list1和list2的头结点，把小的结点拿出来，再继续往下比较，其实都是一个重复的过程。

所以我们可以判断list1和list2的头结点，看哪个头结点更小，然后使较小结点的next指针指向其余结点的合并结果。递归的过程如下图：（摘自LeetCode大佬糜烂的橘子：力扣）

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeTwoLists(self, list1, list2):
        """
        :type list1: Optional[ListNode]
        :type list2: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        #当两个链表都为空，表示链表已合并完成，终止
        if not list1:
            return list2
        if not listl2:
            return list1
        #将小的拿出来，继续递归剩下的
        if list1.val <= list2.val:
            list1.next = self.mergeTwoLists(list1.next,list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1,list2.next)
            return list2

记评论区一位大佬CQQ对 return list1的理解 ：

时间复杂度：O(m+n)

m，n 为 l1​ 和 l2​ 的元素个数。递归函数每次去掉一个元素，直到两个链表都为空，因此需要调用 R=O(m+n) 次。而在递归函数中我们只进行了 next 指针的赋值操作，复杂度为 O(1)，故递归的总时间复杂度为 O(T)=R∗O(1)=O(m+n) 。

空间复杂度：O(m+n)

对于递归调用 self.mergeTwoLists()，当它遇到终止条件准备回溯时，已经递归调用了 m+n 次，使用了 m+n 个栈帧，故最后的空间复杂度为 O(m+n)。

法二：暴力迭代（执行用时：28ms，内存消耗：13.1MB）

所谓暴力迭代就是当list1和list2都不是空链表时，判断list1和list2哪一个链表的头节点的值更小，然后将较小的值的节点添加到结果中，当一个节点被添加到结果里之后，将对应链表中的节点向后移一位。

当循环终止时，list1和list2至多有一个是非空的，那么直接将非空链表接在合并列表后面，并返回合并链表即可。

下面链接给出1->4->5和1->2->3->6两个链表迭代合并的详细过程：

力扣

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeTwoLists(self, list1, list2):
        """
        :type list1: Optional[ListNode]
        :type list2: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        prehead = ListNode(-1)
        prev = prehead
        while list1 and list2:
            if list1.val <= list2.val:
                prev.next = list1
                list1 = list1.next
            else:
                prev.next = list2
                list2 = list2.next
            prev = prev.next
        #合并后list1和list2最多只有一个还没被合并完，直接将链表末尾指向未合并完的链表即可
        if list1:
            prev.next = list1
        else:
            prev.next = list2
        return prehead.next

 注：prehead 和 prev ;两个对象使用同一个引用地址; 但是题目要求返回 链表头, 根据链表头才能找出后面的链表; 所以 prehead 没进行next操作, prev 对创建的链添加节点, 返回 链表头 第一个节点是创建的val = -1,所以实际链表头是: prehead.next

 

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

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