Leetcode系列2.两数相加

前言

参加掘金社区一个刷题打卡的活动第3题，也是题库中的第2道题。

题目描述

提供两个非空链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储着（个位在第1个位置），并且每个节点只能存储一位数字。

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

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

**难度等级：**复杂

示例1：

输入：l1 = [2, 4, 3], l2 = [5, 6, 4]
输出：[7,0,8]
解释：342+465=807

提示：

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

解题思路

遇到这个题，首先想到的一个思路就是：

1. 将两个列表做循环，得到两个整数
2. 对两个整数求和
3. 将求和的结果转变成链表形式并返回

这个思路中，需要做3次循环，按照这个思路也实现了，平均耗时76ms，只优于43%的Python3提交记录。然后就在想有没有优化的地方呢？

前面也谈到上面这个思路需要做3次循环，灵机一动，想到也可以通过1次循环来实现，具体的思路是这样的：

1. 对两个列表求一次循坏，循坏获取对应位置上的数字。这里可能有人会想到，如果两个列表的长度不相等怎么办呢，也简单，短的列表在缺失位补0即可
2. 增加一个变量，表示低位向高位进的值，比如：各位数7和5相加，会向十位数进1，那么这个变量的就为1
3. 在循环中，每次从两个链表中获取的值（如果不存在就设置为0）和进位变量的和作为结果链表中的值

这个思路减少了2次循环，最终结果也表明执行速度快了1/3左右。

AC代码

Python3

• 思路1的实现方式

# 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: ListNode, l2: ListNode) -> ListNode:
        l1_number = self.convertListNodeToNumber(l1)
        l2_number = self.convertListNodeToNumber(l2)

        sum_number = l1_number + l2_number
        sum_number_listnode = ListNode()
        sum_number_listnode_first = sum_number_listnode

        if sum_number != 0:
            while sum_number is not 0:
                sum_number_listnode.next = ListNode(val=sum_number % 10)
                sum_number_listnode = sum_number_listnode.next
                sum_number = sum_number // 10

            return sum_number_listnode_first.next
        
        return sum_number_listnode_first

    def convertListNodeToNumber(self, listNode:ListNode):
        listNodeNumber = 0
        listNodeCursor = listNode
        listNodeCursorIndex = 0

        while listNodeCursor is not None:
            listNodeNumber += listNodeCursor.val * 10**listNodeCursorIndex

            listNodeCursorIndex += 1
            listNodeCursor = listNodeCursor.next

        return listNodeNumber

• 思路2的实现方式

# 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: ListNode, l2: ListNode) -> ListNode:
        nums_total = ListNode(-1)
        nums_total_first_node = nums_total

        carry = 0
        while l1 or l2 or carry:
            l1_val = l1.val if l1 else 0
            l2_val = l2.val if l2 else 0

            nums_total.next = ListNode((l1_val + l2_val + carry) % 10)
            carry = (l1_val + l2_val + carry) // 10
            nums_total = nums_total.next

            l1 = l1.next if l1 else None
            l2 = l2.next if l2 else None
        
        return nums_total_first_node.next

JavaScript实现

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    let nums_total = new ListNode(-1)
    let nums_total_first_node = nums_total

    let carry = 0
    let l1_val = 0
    let l2_val = 0
    while (l1 != null || l2 != null || carry != 0) {
        if (l1) {
            l1_val = l1.val
        } else {
            l1_val = 0
        }
        if (l2) {
            l2_val = l2.val
        } else {
            l2_val = 0
        }

        nums_total.next = new ListNode((l1_val + l2_val + carry) % 10)
        carry = (l1_val + l2_val + carry) >= 10 ? 1 :0
        nums_total = nums_total.next

        if (l1) {
            l1 = l1.next
        } else {
            l1 = null
        }
        if (l2) {
            l2 = l2.next
        } else {
            l2 = null
        }
    }

    return nums_total_first_node.next
};

总结

1. 为啥需要定义nums_total_first_node = nums_total，因为，如果只定义一个nums_total，随着程序的运行，nums_total会指向链表的最后的节点，因此，需要一个变量来指向链表的头结点
2. 为啥需要将carry放在while的判断条件里呢，主要是考虑到求和的链表和输入的两个链表都要长的情况，假如说两个链表的最后一位都是9，那么carry的值为1，但是此时l1和l2都是为null，如果判断条件中没有carray，那么最高位不会添加到链表中。