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;
};

結果：也是並沒有那麼快