LeetCode详解之如何一步步优化到最佳解法：21. 合并两个有序链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        if not list1 and not list2:
            return list1

        result = ListNode()
        pt = result
        while list1 and list2: 
            if list1.val >= list2.val:
                pt.val = list2.val
                list2 = list2.next
            else:
                pt.val = list1.val
                list1 = list1.next
            
            if list1 or list2:
                pt.next = ListNode()
                pt = pt.next
        
        if list1:
            while list1:
                pt.val = list1.val
                list1 = list1.next
                if list1:
                    pt.next = ListNode()
                    pt = pt.next
        elif list2:
            while list2:
                pt.val = list2.val
                list2 = list2.next
                if list2:
                    pt.next = ListNode()
                    pt = pt.next

        return result

解法性能：

优化思路：

在上面的代码中，我们需要单独处理两个输入链表都是空链表的原因之一是创建一个新的ListNode节点的话，其val是会有默认值，这样即使我们没有更新输出的链表，其输出结果也是非空链的。但，如果我们在输出的时候，从输出链表的下一个节点开始算起，则即使两个输入链表都为空链表，我们的输出结果也是空链表。因此，我们最后的返回结果为"result.next"，我们就不需要单独在开头进行额外的处理。

此外，在循环中，对于数值比较小的节点，可以直接将这个节点添加到输出链表中，而不是像前面的代码一样，给val这个attribute赋值。然后，因为最终是输出"result.next"，所以在循环中，是给"pt.next"赋值，接着，pt指向它的next节点。

最后，在至少其中一个输入链表遍历完毕后，判断哪一个链表已经遍历完毕，可以直接添加到输出链表的最后，而无需像上面的代码一样再遍历一遍。

在优化完这些后，代码如下所示：

解法2：最终版

代码：

python 复制代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        result = ListNode(-1)
        pt = result
        while list1 and list2: 
            if list1.val >= list2.val:
                pt.next = list2
                list2 = list2.next
            else:
                pt.next = list1
                list1 = list1.next
            
            pt = pt.next
        
        if list1:
            pt.next = list1
        elif list2:
            pt.next = list2

        return result.next

解法性能：

解法分析：

在优化后，因为少遍历一些循环以及判断，所以，所需要的执行时间减少了。此外，因为代码数量的减少，也减少了需要的内存。