Leetcode2: Add Two Numbers

这道题的难度是简单，说也简单，但也不简单

说不简单是因为，我为了这个审题的事儿，磨蹭了大半天

说简单是因为，审题审清楚了以后，写写也没多久

来看题目，他用一个链表的结构，来代表2个非负数，而非负数是链表中结点的数据元素，不过他是倒序的，也就是头结点是3和4

然后对应位数两两相加，输出一个也是链表类型的结果

接下来说觉得不简单的地方，因为，python里面是没有链表结构的，需要自己去实现

而这道题给你的测试代码是2组列表，[5,4,3] [2,6,4]

我纠结了大半天的原因是，输入的list怎么变成结点呢？难道要自己造轮子？？？？

后来去看了别人的解答，没有看具体过程，就是看个开头，怎么处理从list到Node的过程，无一例外全部直接用 l1和l2代表结点了

奇了怪了。。。。最后研究发现，leetcode在题目里面实际上后台自动把列表转换成ListNode类型了，所以才可以这么用。。。。。

接下来就比较简单了，链表的最大特点就是一半数据域，一半指针域，指针域指向后面那个结点

来看代码吧

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

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """

        if not l1:          #如果l1是空的
            return l2       #直接返回l2
        if not l2:          #如果l2是空的
            return l1       #直接返回l1
        else:
            new = ListNode(0)    #如果两者都是非空的，则建立一个头结点，数据域val=0,指针域暂时为None
            result = new         #复制一份头结点保留在原地开头
            carry = 0            #carry的意思是如果2者相加超过10，则进位以后剩余的值是多少
            while l1 and l2:     #开始循环，当l1和l2都有剩余结点的时候
                add = 0          #两个元素相加的值初始为0
                add = l1.val + l2.val + carry   #两个元素相加的值等于两个元素的值加上进位上来的值
                carry = 0        #值在上一轮进位被使用之后，被清0
                if add > 9:      #如果这一轮的两个元素值相加大于9需要进位
                    carry = add//10  #carry等于进位值，其实也就是1
                    add -= 10        #相加的元素在进位之后减去10
                new.next = ListNode(add)  #将上一个结点和新生成的结点连接起来
                new = new.next       #并将需要计算的结点位置向前挪动一位，作用和指针一样
                l1=l1.next           #将l1和l2的结点各自移动一位
                l2=l2.next
            if l1:               #如果l1比l2长
                while l1:        #循环l1到没有结点
                    add = 0      
                    add = l1.val + carry + 0  #虚拟一个l2的结点元素值为0
                    carry = 0
                    if add > 9:
                        carry = add//10
                        add -= 10
                    new.next = ListNode(add)
                    new = new.next
                    l1 = l1.next
            if l2:               #如果l2比l1长
                while l2:
                    add = 0
                    add = l2.val + carry + 0
                    carry = 0
                    if add > 9:
                        carry = add//10
                        add2 -= 10
                    new.next = ListNode(add)
                    new = new.next
                    l2 = l2.next
            if carry:            #如果总的结束之后，还有进位上来的数，则需要新建一个结点进行连接
                new.next = ListNode(carry)
            return result.next   #result还是停留在头结点的位置，返回的是他的next，也就是第一个结点

题目完成，感觉审题比解决要难啊............

PS: 最后加一段轮子，这个可以实现list和ListNode的相互转换

class ListNode(object):
    def __init__(self,val):
        self.val = val
        self.next = None
    def __repr__(self):
        return str(self.val)
 
def LinkedList(pythonlist):
    l = ListNode(pythonlist[0])
    c = l
    for i in range(1,len(pythonlist)):
        l.next = ListNode(pythonlist[i])
        l = l.next
    return c
 
def PythonList(ListNode):
    l = []
    while ListNode != None:
        l.append(ListNode.val)
        ListNode = ListNode.next
    return l
     
class Solution(object):        
    def mergeTwoLists(self,l1,l2):
        if l1 is None:
            return l2
        if l2 is None:
            return l1
 
        dummyhead=ListNode(0)
        dummyhead.next=None
        p=dummyhead
        while l1 is not None and l2 is not None:
            if l1.val<l2.val:
                p.next=l1
                l1=l1.next
            else:
                p.next=l2
                l2=l2.next
            p=p.next
            if l1 is not None:
                p.next=l1
            else:
                p.next=l2
        return dummyhead.next