合并两个排序的链表

合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
思路：

1. 分别创建cur1  cur2，指向两个链表的表头
2. 创建head变量 存储新链表的表头
3. 向新链表中添加数据：
链表1有数据，链表2没数据的情况，新链表为链表1
链表1没有数据，链表2有数据的情况，新链表为链表2
链表1 链表2都没数据的情况，新链表为空

两个链表都有数据的情况：
   链表1的val小于链表2的val cur1的值加入新链表
   链表1的val大于链表2的val cur2的值加入新链表
   链表1的val等于链表2的val cur1的值先加入新链表  cur2的值先加入新链表
   两个链表遍历完成，在新链表的表尾增加None

代码：

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        cur1 = pHead1    #链表1
        cur2 = pHead2    #链表2
        head = None      #新链表的头
        cur = None       #游标
        # 链表1有数据，链表2没数据的情况，新链表为链表1
        if pHead1 and not pHead2:
            head = pHead1
            return head
        # 链表1没有数据，链表2有数据的情况，新链表为链表2
        if not pHead1 and pHead2:
            head = pHead2
            return head
        # 链表1 链表2都没数据的情况，新链表为空
        if not pHead1 and not pHead2:
            return head
		#两个链表都有数据的情况
        while True:
            # 两个链表都有数据节点
            if cur1 and cur2:
                # 链表1的val小于链表2的val cur1的值加入新链表
                if cur1.val < cur2.val:
                    if head == None:
                        cur = cur1
                        head = cur
                        cur1 = cur1.next
                        head.next = cur1
                    else:
                        cur.next = cur1
                        cur = cur.next
                        cur1 = cur1.next
                # 链表1的val大于链表2的val cur2的值加入新链表
                elif cur1.val > cur2.val:
                    if head == None:
                        cur = cur2
                        head = cur
                        cur2 = cur2.next
                        head.next = cur2
                    else:
                        cur.next = cur2
                        cur = cur.next
                        cur2 = cur2.next
                # 链表1的val等于链表2的val cur1的值先加入新链表  cur2的值先加入新链表
                else:
                    if head == None:
                        cur = cur1
                        head = cur
                        cur1 = cur1.next
                        head.next = cur1
                    else:
                        cur.next = cur1
                        cur = cur.next
                        cur1 = cur1.next

                        cur.next = cur2
                        cur = cur.next
                        cur2 = cur2.next
            # 链表1有数据节点，链表2没有数据节点
            elif cur1  and not cur2:
                cur.next = cur1
                cur = cur.next
                cur1 = cur1.next
            # 链表1没有数据节点，链表2有数据节点
            elif not cur1 and cur2:
                cur.next = cur2
                cur = cur.next
                cur2 = cur2.next
            else:          # 两个链表遍历完成，在新链表的表尾增加None
                cur.next = None
                print('--head--', head.val)
                break
        return head

if __name__ == '__main__':
    # 链表1
    head1 = None
    # head1 = ListNode(100)
    # head1.next = ListNode(200)
    # head1.next.next = ListNode(300)
    # head1.next.next.next = ListNode(500)
    # 链表2
    head2 = ListNode(10)
    head2.next = ListNode(100)
    head2.next.next = ListNode(200)
    head2.next.next.next = ListNode(400)
    # 合并链表
    s = Solution()
    result = s.Merge(head1,head2)
    cur = result
    while cur:
        print(cur.val, end=' ')
        cur = cur.next