题目分析和实现

逻辑上很简单。
解题的时候要注意特殊情况和空值的判断。

解法一

初步想法是先将链表还原成数字，然后数字相加，然后将数字转换成链表。

  1. class Solution:
  2.     def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
  3.         number_one=0
  4.         base_number_one=1# 基数
  5.         number_two=0
  6.         base_number_two=1
  7.         while l1!=None:
  8.             t=l1.val*base_number_one
  9.             base_number_one=base_number_one*10
  10.             number_one=number_one+t
  11.             l1=l1.next
  12.         while l2!=None:   
  13.             t=l2.val*base_number_two
  14.             base_number_two=base_number_two*10
  15.             number_two=number_two+t
  16.             l2=l2.next
  17.         res_number=number_one+number_two
  19.         res_link=ListNode(0) # 初始化一个链表
  20.         if res_number==0:# 排除特殊的情况0
  21.             return res_link
  22.         result=res_link # result作为头指针
  23.         # res_link 作为链表指针，然后构造链表
  24.         while res_number!=0:
  25.             # 取数操作
  26.             t=res_number%10 
  27.             res_number=res_number//10
  28.             # 更新链表指针
  29.             res_link.next=ListNode(t)
  30.             res_link=res_link.next
  31.         return result.next # 受语言特性的影响，开始的一个节点是哑元节点

解法二

很显然上述的方法效率不算高，因为我们完全可以在迭代l1和l2的时候完成数的相加，不需要来回转换。

  1. class Solution:
  2.     def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
  3.         res_link=ListNode(0)
  4.         result=res_link
  5.         carry=0
  6.         while l1 or l2 or carry:
  7.             t=0
  8.             if l1:
  9.                 t=t+l1.val
  10.                 l1=l1.next
  11.             if l2:
  12.                 t=t+l2.val
  13.                 l2=l2.next
  14.             if carry:
  15.                 t=t+carry
  16.                 carry=0
  17.             if t>=10:# 也可以使用carry, val = divmod(carry, 10)来取得整倍数和取模值
  18.                 t=t-10
  19.                 carry=1
  20.             res_link.next=ListNode(t)
  21.             res_link=res_link.next
  22.         return result.next