学习记录：js算法（三十）：两数相加

两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：（图一）
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

我的思路
循环
网上思路
递归

我的思路

var addTwoNumbers = function (l1, l2) {
    const dummy = new ListNode(0);
    let current = dummy;
    let carry = 0;
    while (l1 || l2 || carry) {
        let sum = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + carry;
        carry = Math.floor(sum / 10);
        current.next = new ListNode(sum % 10);
        current = current.next;
        if (l1) l1 = l1.next;
        if (l2) l2 = l2.next;
    }
    return dummy.next;
};

讲解

1. 初始化：创建一个虚拟头结点 dummy 和一个指向 dummy 的指针 current，同时初始化一个变量 carry 表示进位。
2. 遍历链表：同时遍历两个链表，直到两个链表都遍历完并且没有进位为止。
3. 计算当前位的和：将两个链表当前节点的值相加，再加上 carry。然后取模 10 得到当前位的结果，整除 10 得到新的 carry。
4. 创建新节点：创建一个新节点，值为当前位的结果，将新节点连接到 current 的后面，然后将 current 指向新节点。
5. 移动链表指针：将两个链表的指针分别向后移动。
6. 处理进位：如果一个链表已经遍历完，而另一个还有节点或者还有进位，那么继续创建新节点，值为链表节点的值加上进位，重复第3到第5步。
7. 返回结果：当两个链表都遍历完且没有进位时，返回 dummy.next，即为最终的链表。

网上思路

var addTwoNumbers = function (l1, l2, carry = 0) {
    if (l1 === null && l2 === null) { // 递归边界：l1 和 l2 都是空节点
        return carry ? new ListNode(carry) : null; // 如果进位了，就额外创建一个节点
    }
    if (l1 === null) { // 如果 l1 是空的，那么此时 l2 一定不是空节点
        [l1, l2] = [l2, l1]; // 交换 l1 与 l2，保证 l1 非空，从而简化代码
    }
    const sum = carry + l1.val + (l2 ? l2.val : 0); // 节点值和进位加在一起
    l1.val = sum % 10; // 每个节点保存一个数位
    l1.next = addTwoNumbers(l1.next, (l2 ? l2.next : null), Math.floor(sum / 10)); // 进位
    return l1;
};

讲解

1. 递归边界：如果 l1 和 l2 都是 null（即都遍历完了），检查 carry 是否为 0。
   如果 carry 不为 0，说明还有一个进位需要创建新的节点。
   如果 carry 为 0，直接返回 null。
   如果 l1 是 null，那么 l2 一定是非 null。此时交换 l1 和 l2，确保 l1 是非空的，从而简> 化后续的代码逻辑。
2. 计算当前位的和：将 carry、l1 的值和 l2 的值（如果 l2 非空则取值，否则取 0）相加。
   将 l1 节点的值更新为 sum 的个位数（即 sum % 10），这表示当前位的结果。
3. 递归调用 addTwoNumbers 函数，处理下一个节点：
   l1.next 是下一个 l1 节点。
   l2.next 是下一个 l2 节点（如果 l2 为空则传入 null）。
   Math.floor(sum / 10) 计算新的进位。
4. 返回更新后的 l1 节点，这样可以保持链表的结构。

总结

果然还是有递归的解法。