2.两数相加

题目链接
题目要求
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

第一想法当然是万金油的暴力,不过这个暴力居然可以成功,第一次的运行超了80%的人吓死我了,后面又运行了几遍,终于是回归正常水平.

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        #创建两个字符串保存对应的值
        s1,s2='',''
        tail=l1
        while tail:
            #tail不为空则进来
            s1+=str(tail.val)
            #向后移
            tail=tail.next
        s11=''
        for i in range(len(s1),0,-1):
            s11+=s1[i-1]
        i1=int(s11)
        tail = l2
        while tail:
            # tail不为空则进来
            s2 += str(tail.val)
            # 向后移
            tail = tail.next
        s22 = ''
        for i in range(len(s2), 0, -1):
            s22 += s2[i - 1]
        i2 = int(s22)
        s_he=i1+i2
        #现在已经求完了和,那么就应该放入列表了
        head=ListNode(s_he%10)
        s_he=s_he//10
        tail=head
        while s_he>0:
            tail.next=ListNode(s_he%10)
            tail=tail.next
            s_he=s_he//10
        return head

这个是暴力的方法没什么技术含量,但是我现在的要求是你先写出来,优化的事情后面再去说,不要想着一上来就写的很好,时间复杂度高了就看不上

第二种写法从第一个结点开始相加,用一个东西记录次数,再把所有的和加在一起
思路是说我同时对两个链表进行遍历,对应结点进行计算,这个的好处在于减少遍历的次数
用列表储存对应的元素值,用一个i来记录这是第几个结点,然后乘以相应的倍数.

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        #创建用于记录的列表
        _list=[]
        #创建用于记录当前次数以此来进行计算变量
        i=0
        while l1 and l2:  #l1或l2有一为空时,循环结束
            _list.append((l1.val+l2.val)*10**i)
            #向后移
            l1=l1.next
            l2=l2.next
            i+=1
        #出来的时候可能l1或l2非空
        while l1:
            _list.append(l1.val*10**i)
            i+=1
            l1=l1.next
        while l2:
            _list.append(l2.val*10**i)
            i+=1
            l2=l2.next
        #进行循环求和       其实好像在前面的循环就可以直接把和算出来
        s=0
        for i in _list:
            s+=i
        #得到和,开始构建链表
        head=ListNode(s%10)
        tail=head
        s=s//10
        while s>0:
            tail.next=ListNode(s%10)
            tail=tail.next
            s//=10
        return head

写的时候发现了一个问题,为什么我不能直接拿一个变量去记录和,而要拿一个链表去进行遍历,这在后面又有一个o(min(m,n))的操作

改了一下,把列表换成了记录和的变量s,减少的挺多的

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        #创建用于记录和的变量
        s=0
        #创建用于记录当前次数以此来进行计算变量
        i=0
        while l1 and l2:  #l1或l2有一为空时,循环结束
            s+=(l1.val+l2.val)*10**i
            #向后移
            l1=l1.next
            l2=l2.next
            i+=1
        #出来的时候可能l1或l2非空
        while l1:
            s+=l1.val*10**i
            i+=1
            l1=l1.next
        while l2:
            s+=l2.val*10**i
            i+=1
            l2=l2.next
        #得到和,开始构建链表
        head=ListNode(s%10)
        tail=head
        s=s//10
        while s>0:
            tail.next=ListNode(s%10)
            tail=tail.next
            s//=10
        return head

上面代码的思想基本上都是先求和,在进行链表的链接.那么如何才能在链表相加过程中,直接的进行存储呢?当然是有方法的只是需要注意进位的问题

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        #首先创建一个链表
        head=ListNode()
        tail=head
        #进位变量
        jin=0
        while l1 and l2:
            #保存对应结点求和结果
            s=l1.val+l2.val
            #新链表当前结点保存数据
            tail.next=ListNode((s+jin)%10)
            tail=tail.next
            #保存进位
            jin=(s+jin)//10
            l1=l1.next
            l2=l2.next
        #当循环结束时,l1或l2有剩余那么继续进行链接
        while l1:
            s=l1.val
            tail.next=ListNode((s+jin)%10)
            tail=tail.next
            jin=(s+jin)//10
            l1=l1.next
        while l2:
            s=l2.val
            tail.next=ListNode((s+jin)%10)
            tail=tail.next
            jin=(s+jin)//10
            l2=l2.next
        if jin!=0:
            tail.next=ListNode(jin)
        return head.next

这个是采用进位的写法,相对而言的时间复杂度会好一些