Python解决-力扣002-两数相加

两数相加：链表表示的逆序整数求和

在这篇技术博客中，我们将讨论一个力扣（LeetCode）上的编程题目：两数相加。这个问题要求我们处理两个非空链表，它们表示两个非负整数。每个链表中的数字都是逆序存储的，我们需要将这两个整数相加，并以相同的形式返回一个表示和的链表。

题目描述

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

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

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

示例

示例 1：

输入：l1 = , l2 =
输出：
解释：342 + 465 = 807.

示例 2：

输入：l1 = , l2 =
输出：

示例 3：

输入：l1 = , l2 =
输出：[8,9,9,9,

• 每个链表中的节点数在范围 [1, 100] 内
• 0 <= Node.val <= 9
• 题目数据保证列表表示的数字不含前导零

解题思路

为了解决这个问题，我们可以模拟整数加法的过程。首先，我们需要从两个链表的头节点开始，将它们的值相加，然后考虑进位。接下来，我们将两个链表的指针向后移动，并重复这个过程，直到到达链表的尾部。如果在链表的尾部仍然有进位，我们需要添加一个新的节点来存储这个进位。

# 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: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        res = ListNode()     
        t = res
        t.val = (l1.val + l2.val) % 10
        temp = (l1.val + l2.val) // 10
        while l1.next or l2.next:
            t.next = ListNode()
            t = t.next
            if l1.next and l2.next:
                l1 = l1.next
                l2 = l2.next
                t.val = (l1.val + l2.val + temp) % 10
                temp = (l1.val + l2.val + temp) // 10
            elif l1.next and not l2.next:
                l1 = l1.next
                t.val = (l1.val + temp) % 10
                temp = (l1.val + temp) // 10
            elif l2.next and not l1.next:
                l2 = l2.next
                t.val = (l2.val + temp) % 10
                temp = (temp + l2.val) // 10
        if temp:
            t.next = ListNode(temp)
        return res

代码提炼简化

关键的优化点，以及如何从原始代码逐步转换为优化后的代码：

1. 统一处理循环条件：原始代码中，我们需要在循环内部分别处理 l1 和 l2 的情况。优化后的代码将这些条件合并到一个循环中，使得代码更简洁。我们使用 l1 or l2 or carry 作为循环条件，这样可以确保在两个链表都遍历完且无进位时才退出循环。

2. 简化值获取：在原始代码中，我们需要在循环内部分别获取 l1 和 l2 的值。优化后的代码通过使用 val1 = l1.val if l1 else 0 和 val2 = l2.val if l2 else 0 来简化值的获取。这样，我们可以在一行代码中处理 l1 和 l2 是否存在的情况，避免了额外的条件判断。

3. 简化进位处理：原始代码中，我们需要在循环内部分别计算和更新进位值。优化后的代码将进位处理逻辑简化为 carry = total // 10。这样，我们可以在一行代码中更新进位值，避免了额外的条件判断。

4. 简化链表节点创建：原始代码中，我们需要在循环内部分别创建新的链表节点。优化后的代码通过使用 t.next = ListNode(total % 10) 来简化链表节点的创建。这样，我们可以在一行代码中创建新的链表节点，避免了额外的条件判断。

5. 简化链表遍历：在原始代码中，我们需要在循环内部分别更新 l1 和 l2。优化后的代码通过使用 l1 = l1.next if l1 else None 和 l2 = l2.next if l2 else None 来简化链表的遍历。这样，我们可以在一行代码中处理 l1 和 l2 是否存在的情况，避免了额外的条件判断。

# 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: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        res = ListNode()
        t = res
        carry = 0

        while l1 or l2 or carry:
            if l1:
                val1 = l1.val
                l1 = l1.next
            else:
                val1 = 0

            if l2:
                val2 = l2.val
                l2 = l2.next
            else:
                val2 = 0

            total = val1 + val2 + carry

            carry = total // 10
            t.next = ListNode(total % 10)
            t = t.next

        return res.next

总结

这个问题是一个很好的链表操作练习，可以帮助我们熟悉链表的基本操作和加法运算的处理。