0021.MergeTwoSortedLists

#----------------------------class init--------------------------------
class ListNode(object): 
    def __init__(self, val, next=None):  
        self.val = val
        self.next = next

class LinkList(object):
    def __init__(self):
        self.head = None  #给每个实例LinkList创建一个实例属性head，专门用于记录链表首地址（也即链表的第一个节点）；l是链表(实例)，但只具有一个实例属性head；l.head是节点(实例)，才具有实例属性val和next；

    def initList(self,sourceList):
        self.head = ListNode(sourceList[0])
        p = self.head
        for i in sourceList[1:]:
            p.next = ListNode(i)
            p = p.next

    def getLength(self):
        len = 0
        p = self.head 
        while p:
            len += 1
            p = p.next
        return len
  
    def __len__(self):  #特殊方法(魔术方法)：执行len(my_objects)时，如果my_objects是一个自定义的类的对象，需要重写__len__()方法；此时len(l)和l.getLength()结果一样，且前者更简单易懂；
        len = 0
        p = self.head 
        while p:
            len += 1
            p = p.next
        return len

    def deleteElembyIndex(self,index):  #only delete 1 matched element
        if index < 0 or index > self.getLength()-1:
            print('index is not available\n')
            exit(0)
        p = self.head
        i = 0
        if index == 0:
            self.head = p.next
        else:
            while p.next: 
                pre = p    
                p = p.next
                i += 1
                if i == index:
                    pre.next = p.next
                    break

    def deleteElembyValue(self,value):  #delete all matched elements
        p = self.head
        while p.val == value:  #循环结束时，p所指向的节点已处理，下一个循环从p.next继续处理即可
            self.head = p.next
            p = p.next
        while p.next:  #注意这里不能用p，否则遍历到最后一个节点时，p=p.next=None，None.val会报错！   
            pre = p    
            p = p.next
            if p.val == value:
                pre.next = p.next
                p = pre

    def printList(self):  #这里的self是链表(实例)，要用的是self.head(也是实例，但是是节点实例)
        p = self.head  #这里也可以直接用self.head；但最好用一个p来指向每个节点，再直接用p；
        while p:
            print(p.val)
            p = p.next

#--------input---------
list1 = [2,5,7,9]
list2 = [2,3,4,5,6,7,8]

l1 = LinkList()
l2 = LinkList()
lmerge = LinkList()

l1.initList(list1)
l2.initList(list2)

#----------------------------main function--------------------------------
#时间复杂度 O(m+n)  m,n分别为l1,l2节点个数
#空间复杂度 O(m+n)
''' 
1.递归函数的规律：
1）递归函数必须要有终止条件，否则会出错；
2）递归函数先不断调用自身，直到遇到终止条件后进行回溯，最终返回答案。
2.本题思路：
mergeTwoLists(a,b)：连接两个链表的函数，a,b分别是两个链表的初始地址，该函数返回两个链表合并后的初始地址
1）终止条件：当l1或者l2中有一个为空时，返回另一个
2）递归调用：每次调用mergeTwoLists只比较两个节点，选出较小节点，将去掉该节点后 剩下的两个链表继续连接，并把合并结果的 地址返回给该较小节点
换个描述————如果l1.val小于l2.val，那么将l1.next指向 l1的后续节点和l2中较小的一个

'''
def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:  
    if not l1:  # 1）终止条件
        return l2
    if not l2:
        return l1
    if l1.val < l2.val:  # 2）递归调用
        l1.next = mergeTwoLists(l1.next,l2)  #在leetCode中要用self.mergeTwoLists，why？
        return l1  #一开始没想明白这里为什么要return，实际上第一次进判断时是不会走到这里的，而是“陷在”上面的mergeTwoLists里，直到把去掉该节点的剩余所有节点 都合并后，才会最终返回该节点的地址；如果还是想不明白，可以用l1=(2),l2=(3)画图理解下；
    else:
        l2.next = mergeTwoLists(l1,l2.next)
        return l2

lmerge.head = mergeTwoLists(l1.head,l2.head)

#--------output---------
lmerge.printList()
# print(lmerge.getLength())

# lmerge.deleteElembyValue(5)
# lmerge.printList()
# print(lmerge.getLength())
# print(len(lmerge))