如何修改LeetCode第2题代码，解决结果链表初始节点值为0的问题？

原代码存在的问题 #

• 返回的结果链表头部多了一个初始的0节点：你初始化res = ListNode()时，这个节点的val默认是0，而实际有效结果是从res.next开始的，直接返回res会导致结果多一个前置0。
• 未处理两个链表长度不一致的情况：原代码的while l1 and l2只遍历到两个链表都有节点的部分，任意一个链表剩余的节点会被忽略，导致求和计算错误。
• 字符串转整数的方式偏离题目考察初衷：这道题核心是考察链表遍历、节点操作及进位处理逻辑，用字符串转整数的方法绕开了这些关键点，且当链表极长时，效率远低于直接操作链表。

方案1：修复原解法的问题 #

先解决当前的0节点问题，同时补全链表长度不一致的处理：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        v1 = ""
        v2 = ""
        temp = []

        # 遍历l1所有节点，避免遗漏
        while l1:
            v1 += str(l1.val)
            l1 = l1.next
        # 遍历l2所有节点，避免遗漏
        while l2:
            v2 += str(l2.val)
            l2 = l2.next
        
        v1 = v1[::-1]
        v2 = v2[::-1]

        total = int(v1) + int(v2)
        # 把和的每一位逆序存入temp，同时转成整数符合节点val类型
        for char in str(total)[::-1]:
            temp.append(int(char))
        
        # 直接用第一个有效节点初始化结果链表，避免前置0
        if not temp:
            return None
        res = ListNode(temp.pop(0))
        curr = res
        while temp:
            curr.next = ListNode(temp.pop(0))
            curr = curr.next
        return res

修改点说明：

1. 分开遍历两个链表，确保所有节点的数值都被收集
2. 用temp的第一个元素直接初始化结果链表，不再使用默认val为0的节点
3. 将temp中的字符串转为整数，符合ListNode的val类型要求

方案2：正统链表逐位相加（加深链表理解） #

这种方法直接操作链表处理进位，完全贴合题目考察核心：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        # 用**哑节点（dummy node）**简化链表创建，避免判断初始空链表
        dummy = ListNode()
        curr = dummy
        carry = 0  # 存储进位值
        
        # 遍历直到两个链表都为空且无剩余进位
        while l1 or l2 or carry:
            # 取当前节点值，链表为空则补0
            val1 = l1.val if l1 else 0
            val2 = l2.val if l2 else 0
            
            # 计算当前位总和与新的进位
            total = val1 + val2 + carry
            carry = total // 10
            curr_val = total % 10
            
            # 创建新节点并移动指针
            curr.next = ListNode(curr_val)
            curr = curr.next
            
            # 移动原链表指针
            if l1:
                l1 = l1.next
            if l2:
                l2 = l2.next
        
        # 哑节点的next就是结果链表的有效头部
        return dummy.next

核心思路：

• 哑节点的作用：无需判断结果链表是否为空，统一从哑节点的next开始添加节点，最后返回dummy.next即可避免初始0节点问题。
• 逐位计算逻辑：每次取两个链表当前节点的值（为空则补0），加上进位，计算当前位的数值和新的进位。
• 循环终止条件：确保两个链表遍历完成且无剩余进位，覆盖所有边界情况（比如最后一位相加产生进位的场景）。

这种方法时间复杂度为O(max(n,m))（n、m为两个链表长度），空间复杂度为O(max(n,m))，完全符合题目要求，也能帮你深入理解链表的遍历与节点操作逻辑。

内容的提问来源于stack exchange，提问作者Tahmid Baro Bhuiyan