LeetCode ---- 2两数相加

前言

两数相加 单链表类的实现

---

一、题目

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

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

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

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers

二、解法

1.思考

首先可以看下题目中关于listnode类实现的定义：

class ListNode:
    def __init__(self, val=0, next=None):
       self.val = val
       self.next = next

很简单的一个单链表类的定义，一个元素域，一个链接域，没有设置头部，没有其他删除、插入元素等操作。
尝试创建示例中的两个链表：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]

first_sll = [2,4,3]
second_sll = [5,6,4]

l1 = ListNode(first_sll[0])
p = l1
for i in range((len(first_sll)-1)) :
    p.next = ListNode(first_sll[i+1])
    p = p.next

l2 = ListNode(second_sll[0])
p = l2
for i in range((len(second_sll)-1)) :
    p.next = ListNode(second_sll[i+1])
    p = p.next

如此已经创建了两个单链表，他们的头部分别是l1、l2。
可以对它们进行一次输出：

p = l1 # 或者l2
while  p :
    print(p.val)
    p = p.next

如果这个单链表的定义搞明白的话，做题就很easy了。就是将两个链表的值左对齐，然后依次相加，存入一个新的链表。以下两种特殊情况需要考虑一下:

1. 两个链表长度相等，最右边的如果大于9，结果需要再进位 1；
2. 两个链表长度不等，短链表的最后一位结束后相加如果大于9，需要在长链表的后续一位加上1。

2.解

刚开始写的，很冗长，看了评论区的答案，显得我很呆：

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        result = []
        p1 = l1
        p2 = l2
        carry = 0
        res = 0
        while True :
            res = p1.val + p2.val + carry
            carry = 0
            if res > 9 :
                res = res - 10 
                carry = 1
            result.append(res)
            if p1.next == None and p2.next == None :
                if carry :
                    result.append(1)
                break
            elif p1.next == None :
                p2 = p2.next
                while  p2.next :
                    res = p2.val + carry 
                    carry = 0
                    if res > 9 :
                        res = res - 10 
                        carry = 1
                    result.append(res)
                    p2 = p2.next
                res = p2.val + carry 
                carry = 0
                if res > 9 :
                    res = res -10
                    carry = 1
                result.append(res)
                if carry :
                    result.append(1)
                break
            elif p2.next == None :
                p1 = p1.next
                while  p1.next :
                    res = p1.val + carry 
                    carry = 0
                    if res > 9 :
                        res = res - 10 
                        carry = 1
                    result.append(res)
                    p1 = p1.next
                res = p1.val + carry 
                carry = 0
                if res > 9 :
                    res = res -10
                    carry = 1
                result.append(res)
                if carry :
                    result.append(1)
                break
            p1 = p1.next
            p2 = p2.next
        tar = ListNode(result[0])
        p = tar
        for i in range((len(result)-1)) :
            p.next = ListNode(result[i+1])
            p = p.next
        return tar
#run time: 64ms  memory consump: 15MB 

看了其他人的解法后，发现问题：
用while True 加 if 判断跳出 不如用while p1 or p2 来的简单。
将结果写入列表再转换为单链表不如直接将结果存为单链表。
更改之后的：

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        carry = 0
        result = ListNode(None)
        p = result
        while l1 or l2 or carry :
            carry = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
            p.next = ListNode(carry%10)
            p = p.next
            carry = carry//10
            l1 = l1.next if l1 else 0
            l2 = l2.next if l2 else 0  
        return result.next   
 #run time: 80ms  memory consump: 14.9MB 

思路为： 先创建结果的链表，头部为空值，然后对l1 l2 的val进行相加，并将值加入结果的链表，最后返回结果链表的下一个指针，即l1 l2第一个value相加的地方。
还可以写为递归：

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        def recur(l1, l2,carry):
            if l1 or l2 or carry :
                carry = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
                result = ListNode(carry%10)
                result.next = recur(l1.next if l1 else 0 ,l2.next if l2 else 0 , carry//10)
                return result
            else :
                return None
        return recur(l1,l2,0)
 #run time: 84ms  memory consump: 15MB 

相加思路大致一样，区别在于递归不用创建结果链表的头部。上面那个必须创建，不然会把前面的链接指针覆盖，最后返回的链表只会有一个元素！！！