LeetCode Add Two Numbers 之JavaScript 多种解法

在刚接触到这个题目的时候，看完题目完全的不自所云，所以在网上借鉴了很多解法，才明白了大意：

思路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) {
    var sum=parseInt(l1.val)+parseInt(l2.val);
    var tmp=sum>=10?1:0;
    var pionF=l1.next;
    var poinS=l2.next;
    var data=new ListNode(sum%10);
    var nextList=data;
    while(pionF || poinS || tmp){ 
        if(pionF || poinS){
            sum=parseInt(pionF.val)+parseInt(poinS.val)+tmp;
            pionF=pionF.next;
            poinS=poinS.next;
        }else{
            sum=tmp;
        }
        
        tmp=sum>=10?1:0;
        var info=new ListNode(sum%10);
        nextList.next=info;
        nextList=nextList.next; 

    }
    return data;
};

结果：当然是没有通过，因为没有考率到两个输入的长度可能不一样的问题

思路2：从开始就循环，使用三目运算判断赋值

/**
 * 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) {
    var tmp=0;
    var list=0;
    var data=new ListNode(0);
    var poin=data;
    while(l1 || l2 || tmp){ 
        list++;
        var val1=l1?(l1.val!=null?l1.val:0):0;
        var val2=l2?(l2.val!=null?l2.val:0):0;
        var sum=val1+val2+tmp;
        tmp=sum>=10?1:0;
        
        var info=new ListNode(sum%10);
        poin.next=info;
        poin=poin.next;
        
        l1=l1?(l1.next!=null?l1.next:null):null;
        l2=l2?(l2.next!=null?l2.next:null):null;
        
    }
    return data.next;
};

结果：是通过的但是这个时间却是很长。。。

思路3：因为思路2的结果上LeetCode提示了！=与！==的提示，所以做以下的修改

/**
 * 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) {
    var tmp=0;
    var list=0;
    var data=new ListNode(0);
    var poin=data;
    while(l1 || l2 || tmp){ 
        list++;
        var val1=l1?(l1.val!==null?l1.val:0):0;
        var val2=l2?(l2.val!==null?l2.val:0):0;
        var sum=val1+val2+tmp;
        tmp=sum>=10?1:0;
        
        var info=new ListNode(sum%10);
        poin.next=info;
        poin=poin.next;
        
        l1=l1?(l1.next!==null?l1.next:null):null;
        l2=l2?(l2.next!==null?l2.next:null):null;
        
    }
    return data.next;
};

结果：出乎意料，！=和！==的执行效率区别有那么大么？黑人脸？？？？在JavaScript中==的实现算法要复杂与===，==时候双方类型的不确定所以包含了转型操作

思路4：好吧，承认我拿的是LeetCode答案前面最快的(185ms)，但是实际的速度则没有那么快，可能这是很久以前的答案吧，数据有了变动，所以。。。。

/**
 * 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) {
    carry = 0
    var p1 = l1
    var p2 = l2
    var head = new ListNode(-1)
    var p = head
    while (p1 || p2)
    {
        var v1 = 0
        if (p1)
        {
            v1 = p1.val
            p1 = p1.next
        }
        var v2 = 0
        if (p2)
        {    
            v2 = p2.val
            p2 = p2.next
        }
        var s = v1+v2+carry
        if (s>9)
        {
            carry = 1
            s -= 10
        }
        else
        {
            carry = 0
        }
        p.next = new ListNode(s)
        p = p.next
    }
    if (carry)
    {
        p.next = new ListNode(carry)
    }
    return head.next
};

结果：并没有标注出来的那么快

思路5：递归，这也是前面的答案(189ms)

/**
 * 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) {
    const res = test(l1, l2, [], false);    
    return res;
};

var test = function (l1, l2, res, overflow = false) {
    res = res || [];
    l1 = l1 || { val: 0, next: null };
    l2 = l2 || { val: 0, next: null };
    const val = l1.val + l2.val + Number(overflow);
    if (val >= 10) {
        res.push(val % 10);
        overflow = true;
    } else {
        res.push(val);
        overflow = false;
    }
    
    if (l1.next || l2.next || overflow) {
        test(l1.next, l2.next, res, overflow);
    }
    
    return res;
};

结果：也是并没有那么快