LeetCode系列之——2. Add Two Numbers（JavaScript）

Q:

题目链接：Add Two Numbers
先看题目要求：
You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Example:

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

  你有两个包含有非负整数的非空链表。这些数字按反向顺序存储，它们的每个节点都包含一个数字。将这两个数字相加并返回一个链表。你可以假设这两个数字不以0开头（如023会是23），除非是0本身。

分析
  这个题我真的没看懂什么意思，本来是一道关于链表的题目，但是看到leetcode的测试用例的输入确实两个数组：

  而且期望的输出也是一个数组。懵了…
  后来在discuss里面才看到好多人都对这个有疑问，其实是这样的：
当你选择了语言为JavaScript后，leetcode给出的代码如下：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
//l1、l2链头是低位{个{十{百}}
var addTwoNumbers = function(l1, l2) {

};

  ListNode函数就是链表中节点的构造函数，可以清楚地看到它的数据结构，有两个属性val和next，分别指向该节点的数值以及下个节点对象。而addTwoNumbers 函数的两个入参就是这种数据结构。看到这，我就觉得l1和l2应该是这个样子的：

var l1 = {
    val: 2,
    next: {
        val: 4,
        next: {
            val: 3,
            next: null
        }
    }
};

var l2 = {
    val: 5,
    next: {
        val: 6,
        next: {
            val: 4,
            next: null
        }
    }
};

  而且输出也应该是这个样子的，但是人家的用例明明是个数组，所以其实是LeetCode的js引擎做了一个transform：输入时Array –> {ListNode}，输出时{ListNode} –> Array。至于为什么要这么做呢，我也不清楚，可能是觉得这样比较优雅吧…有位大神就对这个做法提出质疑，说这个没什么意义，还要用一个时间复杂度为O(n)的方法来做转化。
  理解到这一步，这道题目的难易程度估计就可以从Medium降为Easy了，后面主要就是单向链表的操作了。

A:

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
//l1、l2链头是低位{个{十{百}}
var addTwoNumbers = function(l1, l2) {
    var sum  = 0;//每一位的和，从个位开始
    var added = false;//是否有进位
    var target = new ListNode(0)//结果链表的当前节点
    var result = target;//结果链表（最终返回的对象）

    while(l1 !== null || l2 !== null){
        target.next = new ListNode(0);
        target = target.next;
        //不是链尾
        if(l1 !== null){
            sum += l1.val;
            //进行高一位的运算(链表指针前进一位)  写在判断里面，防止没有next属性而报错
            l1 = l1.next;
        }
        if(l2 !== null){
            sum += l2.val;
            //进行高一位的运算(链表指针前进一位)
            l2 = l2.next;
        }
        //如果有低位的进位
        if(added){
            sum++;
            added = false;
        }
        //判断是否需要进位
        if(sum >= 10){
            added = true;
            sum -= 10;
        }
        target.val = sum;
        sum = 0;//清零
    }
    //判断最高位上是否有进位
    if(added){
        target.next = new ListNode(1);
    }
    //去掉链头的0
    result = result.next
    return result
};

  代码中写了一些注释，应该还算比较好理解，主要注意进位的问题还有头尾的临界判断。在没有调试的情况下能把代码写正确我觉得很厉害，我是没有做到。
  时间复杂度为O(Max(m,n))，空间复杂度为O(n)。