JavaScript解决LeetCode算法题（2）——《两数相加》

题目

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

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

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

示例：

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

解题

方法1：

其实这个题目考的就是两个数的相加，只不过两个数的每一位都是存在一个内存中，关键点就是进制这一块。

按照示例来分析：

第一位：2+5=7，然后就第一位是7，进0；
第二位：4+6+0=10， 然后第二位是0，进1；
第三位：3+4+1=8，然后第三位是8，这时候两个链表里面都没值了并且是0，所以就不进级了，（假设这时候是18，则第三位是8，进1到第四位）

其他的这里就不详细解释了，在代码层面详细注释一下，贴代码：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    let result = new ListNode(null), 
        nextNode = result,
        sum = 0,    // 两个相同位置数的相加后的个位数（留在当前层级的）
        nextIndex = 0;      // 需要进制的数（需要进到下一层级的数）
    while(l1 || l2) {
        let val1 = l1 ? l1.val : 0,     // 提取该节点的值
            val2 = l2 ? l2.val : 0;
        sum = (val1 + val2 + nextIndex) % 10;   // 当前位置该存储的值
        nextIndex = Math.floor((val1 + val2 + nextIndex)/10);   // 需要进级的值
        nextNode.next = new ListNode(sum);
        nextNode = nextNode.next;
        if(l1) l1 = l1.next;
        if(l2) l2 = l2.next;
    }
    // 如果l1和l2都遍历完了，然后还有需要进级的值，则多加一位
    if(nextIndex !== 0){
        nextNode.next = new ListNode(nextIndex)
    }
    return result.next;
};

最终执行的结果是：

方法2：

我们发现，这个内存消耗的排名不是很高，原因很可能是，我们使用了一个暂存的result来存储信息，然后我们来尝试直接使用l1或者l2来存储：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    //判断两个链表是否为空
    if(!l1) return l2;
    if(!l2) return l1;
    //把l2的链表的val加等赋值给l1
    l1.val += l2.val;
    // 进位处理 判断加等之后是否进一
    if(l1.val>9){
        //这里只留个位数
        l1.val -=10;
        //然后把进一的值保存起来
        // l1.next和l2.next都不等于null 
        // 进位数据保存到l1.next或l1.next都行
        // l1.next为null 保存到l1.next
        // l2.next为null 保存到l2.next
        if(l1.next && l2.next){
            l1.next.val++;
        }else if(!l1.next){
            l1.next = new ListNode(1);
        }else if(!l2.next){
            l2.next = new ListNode(1)

        }
    }
    // 递归调用
    l1.next = addTwoNumbers(l1.next,l2.next);
    return l1;
};

最终执行出来的结果是，内存明显提升，执行速度有小幅度提升：

类似情况大家可以试一下，不使用递归的情况，我在这里就不作尝试了。

方法3：

注： 这个方法不是通用，只适合小的链表，当链表比较长的时候，会超出数值最大范围，然后计算出错。

可以将链表先转化成数，再将数相加转化成链表。

执行代码如下：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    //判断两个链表是否为空
    if(!l1) return l2;
    if(!l2) return l1;
    let num1 = 0, num2 = 0, total = 0;
    for(let i = 0; ; i++) {
        if(l1) {
            num1 += Math.pow(10, i) * l1.val;
            l1 = l1.next;
        }
        if(l2) {
            num2 += Math.pow(10, i) * l2.val;
            l2 = l2.next;
        }
        if(!l1 && !l2) break;
    }
    total = num1 + num2;
    console.log(total);
    let result = new ListNode(null), nextNode = result;
    do {
        nextNode.next = new ListNode(total%10);
        nextNode = nextNode.next;
        total = Math.floor(total/10);
    }while(total > 0)
    return result.next;
};

附加思考

这题是逆序的方式，如果是正序的情况呢？大家可以思考一下怎么处理。

结语

以上是我对此题的解法，如果有小伙伴有更好的方式，或者非常有趣的思维方式，欢迎一起交流讨论。

希望此文能够解决大家工作和学习中的一些疑问，避免不必要的时间浪费，有不严谨的地方，也请大家批评指正，共同进步！

转载请注明出处，谢谢！