题目

:::info https://leetcode-cn.com/problems/add-two-numbers/
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。**示例 1：
2. 两数相加 - 图1:::

题解

其实很简单一道题，但是由于我对Python链表的语法非常不熟悉，结果就踩了无数坑。
官方给出的 ListNode 格式是这样的：

  1. class ListNode(object):
  2.     def __init__(self, val=0, next=None):
  3.         self.val = val
  4.         self.next = next

我就很天真地以为ListNote就是一个增强了的 list，于是自己咔哧咔哧写了一个实现。
然后一跑测试样例都对，开开心心一提交一堆错误。。。

  1. # 这个在本地能跑通，并且是对的
  2. class ListNode(list):
  3.     def __init__(self, L):
  4.         self.idx = 0
  5.         self.len = len(L)
  6.         super(ListNode, self).__init__(L)
  8.     def __getattr__(self, attr):
  9.         if attr == 'val':
  10.             if self.idx >= self.len:
  11.                 return None
  12.             else:
  13.                 return self[self.idx]
  14.         elif attr == 'next':
  15.             self.idx += 1
  16.             if self.idx >= self.len:
  17.                 return None
  18.             else:
  19.                 return self[self.idx]
  22. def addTwoNumbers(l1, l2):
  23.     """
  24.     :type l1: ListNode
  25.     :type l2: ListNode
  26.     :rtype: ListNode
  27.     """
  28.     L = []
  29.     f = 0
  30.     Flag = True
  31.     while Flag:
  32.         a = l1.val
  33.         if a == None:
  34.             a = 0
  35.         b = l2.val
  36.         if b == None:
  37.             b = 0
  38.         c = (a+b+f) % 10
  39.         f = (a+b+f)//10
  40.         L.append(c)
  41.         l1.next
  42.         l2.next
  43.         if not (l1.val or l2.val):
  44.             Flag = False
  45.         if f > 0:
  46.             Flag = True
  47.     return L
  50. l1 = ListNode([2,4,3])
  51. l2 = ListNode([5,6,4])
  52. print(addTwoNumbers(l1, l2))   #[7, 0, 8]

后来修改了无数次，终于提交过了

  1. # Definition for singly-linked list.
  2. # class ListNode(object):
  3. #     def __init__(self, val=0, next=None):
  4. #         self.val = val
  5. #         self.next = next
  6. class Solution(object):
  7.     def addTwoNumbers(self, l1, l2):
  8.         """
  9.         :type l1: ListNode
  10.         :type l2: ListNode
  11.         :rtype: ListNode
  12.         """
  13.         dummy = L = ListNode(None)
  14.         f = 0
  15.         Flag = True
  16.         while Flag:
  17.             if l1 == None:
  18.                 a = 0
  19.             else:
  20.                 a=l1.val
  21.                 l1=l1.next
  22.             if l2 == None:
  23.                 b = 0
  24.             else:
  25.                 b=l2.val
  26.                 l2=l2.next
  27.             c = (a+b+f) % 10
  28.             f = (a+b+f)//10
  29.             L.next=ListNode(c)
  30.             L=L.next
  32.             if (l1 == None) and (l2 ==None):
  33.                 Flag = False
  34.             if f > 0:
  35.                 Flag = True
  36.         return dummy.next

最后贴一个别人的代码 最直白的写法，还是得加油啊

  1. class Solution:
  2.     def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
  3.         # 创建一个结点值为 None 的头结点, dummy 和 p 指向头结点, dummy 用来最后返回, p 用来遍历
  4.         dummy = p = ListNode(None)          
  5.         s = 0               # 初始化进位 s 为 0
  6.         while l1 or l2 or s:
  7.             # 如果 l1 或 l2 存在, 则取l1的值 + l2的值 + s(s初始为0, 如果下面有进位1, 下次加上)
  8.             s += (l1.val if l1 else 0) + (l2.val if l2 else 0)  
  9.             p.next = ListNode(s % 10)       # p.next 指向新链表, 用来创建一个新的链表
  10.             p = p.next                      # p 向后遍历
  11.             s //= 10                        # 有进位情况则取模, eg. s = 18, 18 // 10 = 1
  12.             l1 = l1.next if l1 else None    # 如果l1存在, 则向后遍历, 否则为 None
  13.             l2 = l2.next if l2 else None    # 如果l2存在, 则向后遍历, 否则为 None
  14.         return dummy.next   # 返回 dummy 的下一个节点, 因为 dummy 指向的是空的头结点, 下一个节点才是新建链表的后序节点