萱仔求职系列——力扣刷题：两数相加

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

解题：

       因为他那个是逆序的，所以直接从两个链表的头节点开始逐位相加，并且保持一个进位值的记录，如果有进位就加上去进位。如果链表的某一位为空，就用 0 代替进行加法操作。把每次加法结果的个位数存入新的链表中，进位则继续存入下一位。当所有节点处理完后，如果进位为 1，则在链表最后再添加一个节点。这个可以用递归来做，也可以不用递归来做，使用迭代的方法做。

递归：

感觉这样结果也不错！

class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        if not l1:
            return l2
        if not l2:
            return l1 
        #l3=ListNode(0)
        l1.val = l1.val+l2.val
        if l1.val >=10:
            l1.next = self.addTwoNumbers(ListNode(l1.val // 10), l1.next) 
            # 以l1为基准,遇到需要进位则递归为l1进位
            l1.val = l1.val % 10
        l1.next = self.addTwoNumbers(l1.next, l2.next)
        return l1

狄俄代：

def addTwoNumbers(l1, l2):
    dummy_head = ListNode()
    current = dummy_head
    carry = 0
    while l1 or l2:
        x = l1.val if l1 else 0
        y = l2.val if l2 else 0
        total = x + y + carry
        carry = total // 10
        current.next = ListNode(total % 10)
        current = current.next
        if l1:
            l1 = l1.next
        if l2:
            l2 = l2.next
    
    # 如果最后还有进位，需要再添加一个节点
    if carry > 0:
        current.next = ListNode(carry)
    
    # 返回结果链表
    return dummy_head.next

实际上，迭代方法和递归方法的时间复杂度是相同的，都是 O(max(m, n))，其中 m 和 n 分别是两个链表的长度。两种方法都需要遍历两个链表中的每个节点一次，因此时间复杂度是一样的。

区别在于空间复杂度！

        迭代方法的空间复杂度为 O(1)（不包括返回结果的链表）。迭代方法只使用了固定数量的额外空间，比如 carry 和一些指针变量，因此它的空间复杂度是常数级的。

        递归方法的空间复杂度为 O(max(m, n))。虽然递归也只处理链表中的每个节点一次，但是由于递归调用函数本身会消耗栈空间，每次递归调用会占用一层栈，栈的深度等于两个链表的最大长度。因此递归方法的空间复杂度是 O(max(m, n))，即与链表的长度有关。

        递归方法：每次递归调用时，都会创建一个新的函数调用帧，保存当前的局部变量和执行位置。当链表长度较大时，递归调用会使栈帧消耗较多内存，最终导致更高的空间复杂度。比如，两个链表的长度总和为 k，递归的调用栈深度就是 k，因此空间复杂度为 O(k)。

        迭代方法：只需使用一组指针遍历链表，不需要保存函数调用帧，所有的操作都在同一个栈帧中进行，因此只占用常数级别的内存。无论链表有多长，空间消耗保持固定。