2.两数相加解题思路和方法---leetcode

2.两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

解题方法：

1.递归法：

get_num 把 ListNode 转为 int
make_list 把数字转为 ListNode（但是不能处理 0）
执行用时 :88 ms, 在所有 Python3 提交中击败了
30.05%的用户
内存消耗 :13.6 MB, 在所有 Python3 提交中击败了5.13%的用户

# 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:
        def get_num(l):
            if not l: return 0
            return l.val + get_num(l.next) * 10
        def make_list(n):
            if n == 0: return None
            l = ListNode(n%10)
            l.next = make_list(n//10)
            return l
        s = get_num(l1) + get_num(l2)
        if s == 0:
            return l1
        return make_list(s)

2.双指针法：

很简单的双指针思路，注意还有剩下的 l1 or l2 节点即可，以及每次的进位 p ，如果有就继续创建节点即可。
执行用时 :72 ms, 在所有 Python3 提交中击败了76.12%的用户
内存消耗 :13.6 MB, 在所有 Python3 提交中击败了5.13%的用户

# 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:
        head = ListNode(0)
        p = 0
        cur = head
        while l1 and l2:
            c = (l1.val + l2.val + p)
            p = c//10
            cur.next = ListNode(c%10)
            cur = cur.next
            l1 = l1.next
            l2 = l2.next
        
        l = l1 or l2
        while l:
            c = (l.val + p)
            p = c//10
            cur.next = ListNode(c%10)
            cur = cur.next
            l = l.next
        
        if p:
            cur.next = ListNode(p)            

        return head.next

3.对象赋值法：

在python中，对象赋值实际上是对象的引用。因此l3是ls的浅复制，两者指向同一个链表。
执行用时 :68 ms, 在所有 Python3 提交中击败了
87.97%的用户
内存消耗 :13.7 MB, 在所有 Python3 提交中击败了5.13%的用户

# 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:
        ls = ListNode(0)
        l3 = ls
        carry = 0
        while l1 or l2:
            val1 = l1.val if l1 else 0
            val2 = l2.val if l2 else 0
            val = val1 + val2 + carry
            if val >= 10:
                carry = 1
                val = val - 10
            else:
                carry = 0
            if l1: l1 = l1.next
            if l2: l2 = l2.next
            l3.next = ListNode(val)
            l3 = l3.next
        if carry > 0:
            l3.next = ListNode(1)
        return ls.next

4.遍历模拟加法计算法：

对两个链表同步进行遍历，按位模拟加法计算，记录进位，在下一位计算时考虑进位，不要忘记的是，遍历结束后如果有进位需要处理。性能一般。
执行用时 :72 ms, 在所有 Python3 提交中击败了76.12%的用户
内存消耗 :13.6 MB, 在所有 Python3 提交中击败了5.13%的用户

# 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:
        if not l1:
            return l2
        if not l2:
            return l1
        add = 0
        head, cur, last = None, None, None
        while l1 or l2:
            sum = (l1.val if l1 else 0) + (l2.val if l2 else 0) + add
            add = sum // 10
            cur = ListNode(sum % 10)
            if last:
                last.next = cur
            if not head:
                head = cur
            l1 = l1.next if l1 else None
            l2 = l2.next if l2 else None
            last = cur
        if add != 0:
            last.next = ListNode(add)
        return head

5.python中对象赋值法：

在python中，对象赋值实际上是对象的引用。因此l3是ls的浅复制，两者指向同一个链表。
执行用时 :76 ms, 在所有 Python3 提交中击败了60.70%的用户
内存消耗 :13.7 MB, 在所有 Python3 提交中击败了5.13%的用户

# 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:
        ls = ListNode(0)
        l3 = ls
        carry = 0
        while l1 or l2:
            val1 = l1.val if l1 else 0
            val2 = l2.val if l2 else 0
            val = val1 + val2 + carry
            if val >= 10:
                carry = 1
                val = val - 10
            else:
                carry = 0
            if l1: l1 = l1.next
            if l2: l2 = l2.next
            l3.next = ListNode(val)
            l3 = l3.next
        if carry > 0:
            l3.next = ListNode(1)
        return ls.next