LeetCode.2 两数相加(Add Two Numbers)(JS)

上周日就想写vue.nextTick的源码分析，可是总是不知道从哪儿下手，今天有时间，先把leetcode第二题补了，感觉这道题还挺简单的

一、题目

两数相加：

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：

示例

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

二、我的答案

/**
 *. 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) { 
      function ListToArray(list) {
        if(list.next) {
          return [list.val, ...ListToArray(list.next)]
        } else {
          return [list.val]
        }
      }
      function sumArray(arr1, arr2) {
        if(arr1.length < arr2.length) {
          let arr = []
          arr = arr1
          arr1 = arr2
          arr2 = arr
        }
        let littleLen = arr2.length
        let i =0
        for(; i < littleLen; i++) {
          arr1[i] += arr2[i]
          if(arr1[i] >= 10) {
            arr1[i] -= 10
            arr1[i + 1] ? arr1[i + 1]++ : arr1[i+1] =1
          }
        }
        for(; i < arr1.length; i++ ) {
          if(arr1[i] >= 10) {
            arr1[i] -= 10
            arr1[i + 1] ? arr1[i + 1]++ : arr1[i+1] =1
          }
        }
        return arr1.reverse()
      }

      function ArrayToList(arr) {
        if(arr.length > 0) {
          let node = new ListNode(arr.pop())
          node.next = ArrayToList(arr)
          return node
        } else {
          return null
        }
      }
      return ArrayToList(sumArray(ListToArray(l1),ListToArray(l2)))
    };

计算两个链表表示的数的和，统共分三步：

1. 把冰箱门打开 链表转数组；
2. 两个数组相加得到和数组；
3. 和数组转链表

我的写法答案简单易懂，就不做解释，这里说一下写的时候碰到一个坑
关于第二步两个数组相加，一开始的思路并不是这样的，而是转成String再转Number相加再转回来，那么这个思路折哪儿了呢，有一个测试用例是[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]和[5,6,4]，转成Number相加得1e+30，没错，万恶的弱类型，查询能不能不转换，未果，就只能遍历各数位相加了

这题一开始没懂啥意思，懂了之后思路还挺清晰的，击败33.45%，嘛，喜闻乐见，看看大手子们是咋写的吧

三、优秀答案

/**
 * 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, curr = 0) {
    if(l1 === null && l2 === null) {
        if(curr) return new ListNode(curr)
        else return null;
    } else {
        if(l1 == null) l1 = new ListNode(0)
        if(l2 == null) l2 = new ListNode(0)
        let nextVal = (l2.val || 0) + (l1.val || 0) + curr
        curr = 0
        if(nextVal > 9) {
            curr = 1
            nextVal -= 10
        }
        l1.val = nextVal
        l1.next = addTwoNumbers(l1.next, l2.next, curr)
        return l1
    }
}; 

这个是我看到的最优秀的答案，本地跑击败91%，甩我不知道几条街，看各种优秀答案总是能刷新认知，来看他的思路
首先他把函数改了，函数的本意是相加两个链表，他改成了相加两个节点，参数中curr的意思是上一组节点相加是否进位这什么命名
再来看函数内，if部分的代码意为处理最后的边界情况，例[1],[9,9,9,9],即遍历完两个链表之后，如果上一次遍历有进位，则new一个节点
else内则是主要的节点相加部分，其中

    if(l1 == null) l1 = new ListNode(0)
    if(l2 == null) l2 = new ListNode(0)
    let nextVal = (l2.val || 0) + (l1.val || 0) + curr

(l2.val || 0)明显是多余的，我猜他本来写的是let nextVal = (l2.val || 0) + (l1.val || 0) + curr但是执行发现null点不出val，就加了上面的判断不过下面的没删，不精简代码差评。
剩下的逻辑就显而易见了，进位什么的，不过这种同步遍历真的很巧妙，我怎么就是学不会/捂脸

四、路漫漫其修远兮

       这几道题提交都是在力扣上的，但是做完这道题去看优秀答案，发现有一个排名较前的答案返回值是Array，我自己复制过来甚至根本过不了测试用例，应该是力扣没有像leetcode更新全面吧，题改了但是答案却没有改，决定以后还是提交到leetCode吧，
       再细看优秀答案的最后三行，怎么总感觉好像可以用尾调用优化一下，有空看一下，今天这篇博客到此为止，下面该做的第四题难度为hard，害怕之余突然有点期待看到各种神仙解法/捂脸。

THE END

---

2019.3.27更新
之前说感觉优秀答案的最后三行可以用尾递归优化（不知道尾递归的小伙伴可以点这里），仔细想了一下，并不能。

尾递归的实现，往往需要改写递归函数，确保最后一步只调用自身。做到这一点的方法，就是把所有用到的内部变量改写成函数的参数。

原因如下：
        假设我们按照上面描述实现尾递归，那么函数需要三个参数，分别是l1, l2，还有当前组装的listNode对象，那么我们每次调用的时候，都需要l1.val + l2.val赋值给当前组装的对象的最深层，要想获得对象的最深层，就得遍历，那我们还优化个锤子。
        不过这么分析下来，优秀答案作者可能本来的意图就是用尾递归优化，所以给第三个参数命名为curr，发现得不偿失后放弃这种做法，把第三个参数的作用改为进位，但是并没有再修改变量名，不过这个编码习惯倒是很符合上文我猜测的let nextVal = (l2.val || 0) + (l1.val || 0) + curr这行代码没有精简的理由。
        分析个优秀答案能分析出破案的感觉我也是服我自己