[LeetCode] 两数相加 （JavaScript 解法）

原题地址： https://leetcode-cn.com/problems/add-two-numbers/

 

题目描述

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

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

 

题目示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

[假] JavaScript 输入

[2,4,3]
[5,6,4]

[假] JavaScript 输出

[7, 0, 8]

 

真实的 JavaScript 输入

这里有一个很坑的地方是虽然上面的输入和输出是数组，但是并不能按照数组输入输出，因为函数上明确写了，输入的是 ListNode 类型。

我在做这个的时候就被数组给迷惑了，怎么输出都是 undefined。

 

而默认 ListNode 这个数据类型是已经存在的，因此在本地写代码的时候，是需要构造 l1 和 l2 两个数据的，否则我不相信凭空就能写出题解来。

首先我们已经知道，l1 和 l2 都是 ListNode 类型，因此输入 [2, 4, 3] 中的 2 / 4 / 3 分别是每个 ListNode 的 val。

因此 l1 可以如下构造：

let l1_1 = new ListNode(2);
let l1_2 = new ListNode(4);
let l1_3 = new ListNode(3);
l1_1.next = l1_2;
l1_2.next = l1_3;

// l1 = l1_1 

　　

同样的 l2 输入可以如下构造：

let l2_1 = new ListNode(5);
let l2_2 = new ListNode(6);
let l2_3 = new ListNode(4);
l2_1.next = l2_2;
l2_2.next = l2_3;

// l2 = l2_1;

　　

因此本地写代码调用的时候实际上如下所示：

const input1 = l1_1;
const input2 = l2_1;

console.log(addTwoNumbers(input1, input2));

　　

 

真实的 JavaScript 输出

从注释上可以发现，最终的输出也是 ListNode 类型的，因此最终输出结果应该如下：

ListNode {
  val: 7,
  next: ListNode { val: 0, next: ListNode { val: 8, next: null } } }

　　

 

 

JavaScript 题解

当理解了 l1 和 l2 都是 ListNode 类型之后，就很好去做这个事情了。

下面代码很简单，主要是两部分：

• 链表的便利
• 个位数相加 、 进位

具体的流程已经写到了注释上。

/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    let resNode = new ListNode(0); // 临时使用的 node 用来不停的增加链表节点
    let result = resNode; // 第一次挂载
    let tmpS = 0; // 相加 > 10 的进位数(1 或 0)
    while(l1 || l2 || tmpS) { // 判断 tmpS 的目的是防止最后还有一位进位需要前置
        let val1 = l1 ? l1.val || 0 : 0; // 需要判断 l1 是 null
        let val2 = l2 ? l2.val || 0 : 0; // 需要判断 l2 是 null
        let sum = val1 + val2 + tmpS; // this.val 相加并加上进位值
        tmpS = sum >= 10 ? 1 : 0; // 计算本次相加是否需要进位
        sum = sum % 10; // 当前位只需要个位数
        if(l1) l1 = l1.next; // 遍历链表
        if(l2) l2 = l2.next; // 遍历链表
        resNode.next = new ListNode(sum); // 将当前结果挂到临时的 node 上
        resNode = resNode.next; // 如果要继续挂载链表，需要将当前的指针移动到 next 上
    }
    return result.next; // result 是 resNode, resNode.next 才是最终结果
};

　　

需要注意的是，resNode 这个链表，需要每次将当前的指针移动到下一个 ListNode，可以打印 resNode 观察过程：

// 打印位置：
// resNode.next = new ListNode(sum); // 将当前结果挂到临时的 node 上
// console.log(resNode);
// resNode = resNode.next; // 如果要继续挂载链表，需要将当前的指针移动到 next 上

ListNode { val: 0, next: ListNode { val: 7, next: null } }
ListNode { val: 7, next: ListNode { val: 0, next: null } }
ListNode { val: 0, next: ListNode { val: 8, next: null } }
// 打印位置：
// resNode.next = new ListNode(sum); // 将当前结果挂到临时的 node 上
// resNode = resNode.next; // 如果要继续挂载链表，需要将当前的指针移动到 next 上
// console.log(resNode);

ListNode { val: 7, next: null }
ListNode { val: 0, next: null }
ListNode { val: 8, next: null }

　　

虽然每次 resNode 都被重新赋值，对于 result 来说，只是指针移动而已，因此它会拥有完整的链表。