LeetCode 21: Merge Two Sorted Lists（合并两个有序链表）

原题

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->4, 1->3->4
Output: 1->1->2->3->4->4

My Solution

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        
        output = ListNode(-1)
        head = output
        if not l1:
            return l2
        if not l2:
            return l1
        
        while l1 and l2:    
            if l1.val > l2.val:  
                output.next = l2
                l2 = l2.next
            else:
                output.next = l1
                l1 = l1.next
            output = output.next
        if l1:
            output.next = l1
        if l2:
            output.next = l2
        return head.next

Reference solution

**思路分析：**我们得知道有效括号的特点 ，肯定都是左括号在一起 ，之后才是右括号 ，而且左右数量等同 ，从中间看来是严格对称的 ，所以最简单的思路就是从中间位置向两端对比 。这里采用另外的方法来实现判断 。

思路一 ：
利用链表已经有序 ，创建一个新链表 ，从头指针开始 ，将两个链表依次比较 ，新目标链表指向比较后较小的链表（记作A）的对应节点值 ，然后将该链表A后移一个节点重复操作 。直到有个链表已经移动到最后 ，此时将另一个链表接到目标链表后即可 ，小詹记得前边有一题特别类似 。具体代码实现如下 ：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1, l2):
        #指向头指针
        head = dummy = ListNode(-1)
        #当两个链表都不为空的时候，比较大小，小的接在目标链表后，并该链表指针后移
        while l1 and l2:
            if l1.val < l2.val:
                head.next = l1
                l1 = l1.next
            else:
                head.next = l2
                l2 = l2.next
            head = head.next
        #这里是当有一个链表后移到了最后，则将剩余一个全部接在目标链表后
        if l1:
            head.next = l1
        if l2:
            head.next = l2
        return dummy.next

思路二：
除了上述思路 ，还可以利用递归思路 ，我们注意到链表指针指向后边的还是一个链表 ，可看作少一个节点的链表 。于是我们可以考虑反复调用该方法 ，只是将参数改成去除一个节点的链表和另一个没有变化的链表即可 ，具体代码如下 :

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1, l2):
     	"""
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2

反思：

1. 解决这道题时候最大的障碍就是不知道如何在python中创建链表，事实上，代码中已经用注释说出了"class ListNode:"，直接套用即可；
2. 此外，本题曾一度纠结在为什么不能直接将l1赋值给output而是直接赋值给output.next（若直接赋值，最终结果永远为初试创建时候的值：-1），这里暂时先留一个小疑问；
3. 最后就是因为赋值时候直接赋值为output.next，所以最终输出始终有初试创建时候的值-1，故而最终返回值为head.next（舍弃创建值-1）