用python实现两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)

输出：7 -> 0 -> 8

原因：342 + 465 = 807

1>思路：正向思维，根据题意直推法。先将两个链表转成列表形式，为了计算两个链表之和，将列表转成字符串形式，再将字符串转成int型整数，此时可计算出和；

因为最后返回的是链表形式，所以计算出和后，将和值转成字符串，然后从后往前遍历字符串，并插入空链表，最后可返回结果链表。

88 ms

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        #链表转成列表
        a1=[]
        a2=[]
        while(l1):
            a1.append(l1.val)
            l1=l1.next
        while(l2):
            a2.append(l2.val)
            l2=l2.next
        #列表转成字符串
        s1=''
        for i in range(len(a1)-1,-1,-1):
            s1=s1+str(a1[i])
        s2=''
        for j in range(len(a2)-1,-1,-1):
            s2=s2+str(a2[j])
        #字符串转成整数
        m1=int(s1)
        m2=int(s2)
        #整数之和转成字符串
        m3=str(m1+m2)
        
        #新建两个空链表
        tmp_node=ListNode(None)
        node=ListNode(None) 
        #从后往前遍历和字符串，插入链表
        for x in m3[::-1]:
            if not tmp_node.val:
                tmp_node.val=x
                node=tmp_node
            else:
                tmp_node.next=ListNode(x)
                tmp_node=tmp_node.next
                      
        return node

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37

2>

84 ms

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        target = ListNode(0)   # 作为根节点的引用
        p = target
        add = 0    # 作为上一次相加是否需要进1的依据
        while l1 and l2:
            p.next = ListNode((l1.val+l2.val+add)%10)
            add = (l1.val+l2.val+add)//10
            p, l1, l2 = p.next, l1.next, l2.next
        l1 = l1 if l1 else l2
        while add:
            if l1:
                p.next = ListNode((l1.val+add)%10)
                add = (l1.val+add)//10
                p, l1 = p.next, l1.next
            else:
                p.next = ListNode(add)
                p = p.next
                break
        p.next = l1 
        
        return target.next

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

3>思路：若两个链表其中之一不为空，就进行下一步，若有一个为空了则其设置val为0。不需要设置多的节点。这种方法的优势在于省空间。

80 ms

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        dummyHead = ListNode(0)
        curr, carry = dummyHead, 0
        while l1 or l2:
            sum = 0
            if l1:
                sum += l1.val
                l1 = l1.next
            if l2:
                sum += l2.val
                l2 = l2.next
            sum += carry
            carry = sum // 10
            curr.next = ListNode(sum % 10)
            curr = curr.next
        if carry > 0:
            curr.next = ListNode(1)
        return dummyHead.next;

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

4>

76 ms

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        
        n = l1.val + l2.val
        l3 = ListNode(n % 10)
        l3.next = ListNode(n // 10)
        p1 = l1.next
        p2 = l2.next
        p3 = l3
        while True:
            if p1 and p2:
                sum = p1.val + p2.val + p3.next.val
                p3.next.val = sum % 10
                p3.next.next = ListNode(sum // 10)
                p1 = p1.next
                p2 = p2.next
                p3 = p3.next
            elif p1 and not p2:
                sum = p1.val + p3.next.val
                p3.next.val = sum % 10
                p3.next.next = ListNode(sum // 10)
                p1 = p1.next
                p3 = p3.next
            elif not p1 and p2:
                sum = p2.val + p3.next.val
                p3.next.val = sum % 10
                p3.next.next = ListNode(sum // 10)
                p2 = p2.next
                p3 = p3.next
            else:
                if p3.next.val == 0:
                    p3.next = None
                break
        return l3

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34