【Leetcode】2:两数相加（Python）

题目：

 解题思路：首先对两个链表进行遍历，然后将数字转化为字符串加起来

     然后对整个字符串进行逆序，在逆序的同时赋值给新创建的链表

代码如下：

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

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        #首先对两个链表进行遍历，然后将数字转化为字符串加起来
        #然后对整个字符串进行逆序，在逆序的同时赋值给新创建的链表
        
        #首先考虑为0的情况


        #考虑链表不为0的情况
        l1_node=[]
        l2_node=[]
        #在储存进数组里的时候可以直接逆序
        while l1:
            l1_node.insert(0,str(l1.val))
            l1=l1.next

        while l2:
            l2_node.insert(0,str(l2.val))
            l2=l2.next
        #转化为整数进行相加
        zhengshu=''
        zhengshuer=''
        for i in l1_node:
            zhengshu=zhengshu+i
        
        for j in l2_node:
            zhengshuer=zhengshuer+j

        zhengshu=int(zhengshu)
        zhengshuer=int(zhengshuer)

        summ=str(zhengshu+zhengshuer)
        #将相加得到的整数再次变成字符串，并分割，分别赋值给新的链表
        ls=[]
        for i in summ:
            ls.append(i)
        node=ListNode(0)
        pointer=node
        #这里还要进行倒序一次
        i=len(ls)-1
        while i>=0:
            
            node.next=ListNode(int(ls[i]))
            node=node.next
            i=i-1
        
        return pointer.next

得解：

 我这个方法还不太行，时间复杂度太大，用了四个并列的循环，之后再来想想有没有更好的办法。

方法二：

然后我看了官方的解答，直接使用初等数学方法求解，如下图所示：

 我们可以观察到链表l1和l2正好从前往后遍历得到的是个位，十位，百位数的数字位数，我们只要把遍历的结果从前往后分别相加到一个新的链表里就正好得到了我们新链表的结果，使用carry代表是否进位，carry=1就进位，carry=0就不进位。同时考虑，两个链表长度不相同的情况，于是可写出以下代码：

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

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        #直接将对应链表元素进行相加，就正好相当于从个位数开始往上面加
        node = ListNode(0)
        pointer = node
        carry = 0
        while l1 != None or l2 != None:
            #那么向后移动到None了后，l2将不会具有val值，这该如何处理？
            if l1!=None and l2!=None:
                if (l1.val + l2.val + carry) >= 10:
                    node.next = ListNode(l1.val + l2.val + carry - 10)
                    node = node.next
                    carry = 1
                if (l1.val + l2.val + carry) < 10:
                    node.next = ListNode(l1.val + l2.val + carry)
                    node = node.next
                    carry = 0
            if l1==None:
                if (l2.val + carry) >= 10:
                    node.next = ListNode(l2.val + carry - 10)
                    node = node.next
                    carry = 1
                if (l2.val + carry) < 10:
                    node.next = ListNode(l2.val + carry)
                    node = node.next
                    carry = 0
            if l2==None:
                if (l1.val + carry) >= 10:
                    node.next = ListNode(l1.val + carry - 10)
                    node = node.next
                    carry = 1
                if (l1.val + carry) < 10:
                    node.next = ListNode(l1.val + carry)
                    node = node.next
                    carry = 0
            if l1 != None:
                
                l1 = l1.next
            if l2 != None:
                l2 = l2.next
                
        if carry == 1:
            node.next = ListNode(1)
            node = node.next


        return pointer.next

最后的运行结果如下所示：

 发现运行用时比我自己想的办法还大，差一点就超时了，这个官方解答真是奇怪。