算法总结（一）

1.两个链表相加

总的来说类似于数学运算，思路就是依次将链表的值取出，然后进行按位相加，必须的变量有一个进位，最后返回链表时需要一个节点，运算方法除了相加还需要进行取模取余，最后由于计算是从低位到高位，所以还需要取节点时进行头部插入。

代码如下。但使用特别特别长的链表时，有时会报超时，需继续优化（TODO）

// 假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。
// 给定两个这种链表，请生成代表两个整数相加值的结果链表。
// 例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

// 超时——TODO
/*
 * function ListNode(x){
 *   this.val = x;
 *   this.next = null;
 * }
 */

/**
 * 
 * @param head1 ListNode类 
 * @param head2 ListNode类 
 * @return ListNode类
 */
 function addInList( head1 ,  head2 ) {
    var arr1 = [],
        arr2 = [],
        // sumArr = [],
        sum = 0,
        deg = 0,
        len = 0
    while(head1 != null || head2 != null) {
        if (head1 != null) {
            arr1.unshift(head1.val)
            head1 = head1.next
        }
        if (head2 != null) {
            arr2.unshift(head2.val)
            head2 = head2.next
        }
        len++
    }
    var p,p1=null
    for (var i=0;i<len;i++) {
        var _sum = (+(arr1[i]||0))+(+(arr2[i]||0))+deg
        // sumArr.push(_sum%10)
        deg = Math.floor(_sum/10)
        p=new ListNode(_sum%10)
        p.next = p1
        p1 = p
    }
    if (deg > 0) {
        // sumArr.push(deg)
        p=new ListNode(deg)
        p.next = p1
    }
//     for (var j=0;j<sumArr.length;j++) {
//         p=new ListNode(sumArr[j])
//         p.next = p1
//         p1 = p
//     }
    return p
}
module.exports = {
    addInList : addInList
};

2.用2个栈实现队列

栈，先进后出，尾部进，尾部出，队列，先进先出，尾部进，头部出。

思路就是进的时候直接进，出的时候先判断一个栈是否空，空的话则全部将另一个栈入栈，非空则直接弹出顶部元素。题目多少比较混淆人。

// 用两个栈来实现一个队列，分别完成在队列尾部插入整数(push)和在队列头部删除整数(pop)的功能。 队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。

// 示例:
// 输入:
// ["PSH1","PSH2","POP","POP"]
// 返回:
// 1,2
// 解析:
// "PSH1":代表将1插入队列尾部
// "PSH2":代表将2插入队列尾部
// "POP“:代表删除一个元素，先进先出=>返回1
// "POP“:代表删除一个元素，先进先出=>返回2

var _quene1 = []
var _quene2 = []
function push(node)
{
    _quene1.push(node)
}
function pop()
{
    if (_quene2.length == 0) {
        while(_quene1.length > 0) {
            _quene2.push(_quene1.pop())
        }
    }
    return _quene2.pop()
}
module.exports = {
    push : push,
    pop : pop
};

3.翻转链表

思路很简单，就是简单的遍历然后翻转指针。

实际操作，首先是进行循环原链表，然后需要一个当前指针变量，还需要一个next节点变量，需要进行到下个节点时，将当前节点变成上个节点，因而一共需要3个变量。循环条件就是节点不为null。需要注意的是操作顺序是严格一步步进行的，因为如果顺序不对，节点会相互缠绕。而最后返回的，则是最后一个节点。而我们循环终止时，最后一个是null，因而再往前的一个节点就是我们要返回的变量。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function ReverseList(pHead)
{
    let cur = pHead
    let pre = null
    while (cur != null) {
        let cnext = cur.next
        cur.next = pre
        pre = cur
        cur = cnext
    }
    return pre
}

4.解析url参数

url的格式：协议://域名(:端口)/url路径?参数1=值1&参数2=值2#锚点id

相应的参数截取方法，则是先以?分割，再以#分割，来截取中间部分，再以&切割开不同键值对，最后以=区分键值。

function getUrlParam(sUrl, sKey) {
    const urlMap = {}
    try {
        let urlMapAr = sUrl.split("?")[1].split("#")[0].split("&")
        urlMapAr.forEach(e => {
            let er = e.split("=")
            if (urlMap[er[0]] === undefined) {
                urlMap[er[0]] = er[1]
            } else {
                if (Array.isArray(urlMap[er[0]])) {
                    urlMap[er[0]].push(er[1])
                } else {
                    urlMap[er[0]] = [urlMap[er[0]], er[1]]
                }
            }
        })
    } catch(e) {}
    return sKey ? (urlMap[sKey] || "") : urlMap
}

5.青蛙跳（斐波那契数列-递归）

问题抽象为，一次只能加1或者2，要实现和为n，有多少种方法。

n为1时，只有1，n为2时，有2和1,1......。思路的关键点是，要想到达n，则先要到达n-1时最后一步是1，或者到达n-2最后一步是2（是1+1的和n-1重复），因而使用反向递归的方法可以解决。但是其实斐波那契数列在参数稍微大一点时就进行了大量的递归，效率方面有严重不足(10g内存到32就无法计算了)，可以考虑使用其他方法解决。（时间复杂度On方和On的关系）

// 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
function jumpFloor(number) {// On^2，递归
    if (number > 2) {
        return jumpFloor(number - 1) + jumpFloor(number - 2)
    } else {
        return number
    }
}

function jumpFloor(num) {// On，for循环
    if (num > 2) {
        var num1 = 1;
        var num2 = 1;
        for (var i = 2; i < num; i++) {
            num2 = num1 + num2;
            num1 = num2 - num1;
        }
        return num1 + num2;
        // 可以使用解构赋值简化
        // [n1, n2] = [n2, n1 + n2]
        // return n2// 确认没问题吧TODO
    } else {
        return num
    }
}

const fb4 = function(){// 闭包（差了1——TODO），去除重复计算的递归
    var mem = [0,1];
    var f = function(n){
        var res = mem[n];
        if(typeof res !== 'number'){
            mem[n] = f(n-1) + f(n-2);
            res = mem[n];
        }
        return res;
    }
    return f;
}();

// 惰性序列？？TODO

// class Matrix
// {
// public:
//     int n;
//     int **m;
//     Matrix(int num)
//     {
//         m=new int*[num];
//         for (int i=0; i<num; i++) {
//             m[i]=new int[num];
//         }
//         n=num;
//         clear();
//     }
//     void clear()
//     {
//         for (int i=0; i<n; ++i) {
//             for (int j=0; j<n; ++j) {
//                 m[i][j]=0;
//             }
//         }
//     }
//     void unit()
//     {
//         clear();
//         for (int i=0; i<n; ++i) {
//             m[i][i]=1;
//         }
//     }
//     Matrix operator=(const Matrix mtx)
//     {
//         Matrix(mtx.n);
//         for (int i=0; i<mtx.n; ++i) {
//             for (int j=0; j<mtx.n; ++j) {
//                 m[i][j]=mtx.m[i][j];
//             }
//         }
//         return *this;
//     }
//     Matrix operator*(const Matrix &mtx)
//     {
//         Matrix result(mtx.n);
//         result.clear();
//         for (int i=0; i<mtx.n; ++i) {
//             for (int j=0; j<mtx.n; ++j) {
//                 for (int k=0; k<mtx.n; ++k) {
//                     result.m[i][j]+=m[i][k]*mtx.m[k][j];
//                 }
//             }
//         }
//         return result;
//     }
// };
// int main(int argc, const char * argv[]) {
//     unsigned int num=2;
//     Matrix first(num);
//     first.m[0][0]=1;
//     first.m[0][1]=1;
//     first.m[1][0]=1;
//     first.m[1][1]=0;
//     int t;
//     cin>>t;
//     Matrix result(num);
//     result.unit();
//     int n=t-2;
//     while (n) {
//         if (n%2) {
//             result=result*first;
//             }
//         first=first*first;
//         n=n/2;
//     }
//     cout<<(result.m[0][0]+result.m[0][1])<<endl;
//     return 0;
// }
// TODO——改成js

module.exports = {
    jumpFloor: jumpFloor
};