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