大部分玩前端的小伙伴，在算法上都相对要柔弱些，毕竟调款式、调兼容就够掉头发的了，哪还有过剩的头发再去折腾。

确切在前端中须要使用到算法的处所是比较少，但若要往高等方向生长，算法的基本功就异常主要啦。对了，算法在口试中然则必考项啊，所以为了希冀薪资，头发照样得做下捐躯呀。

有些小伙伴以为，刷了那些奇奇怪怪的算法题，可在工作中很少能直接派上用处，嗯，没错，所以学算法是件高耽误满足的事变。那末学算法，究竟收成什么呢？我以为经由过程演习算法，造就我们解决问题的潜意识才是最主要的。

进修算法，最直接有用的就是刷题，刷题有许多渠道，我比较引荐 LeetCode，它有国内和外洋版，异常轻易。如今网上有许多大牛都分享各自刷题的解法，但百读不如一练嘛，所以我也开个【来刷LeetCode】系列，由浅入深，分享我的解法和思绪，由于我的解法一定不是最棒的，所以还会在加上我以为优异的解法。

哔哔了这么多，我们如今开撸。代码略多，发起人人先点个赞（我就是来骗赞的~）

两数之和

两数之和，问题形貌以下：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你能够假定每种输入只会对应一个答案。然则，你不能反复应用这个数组中一样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

由于 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

我的思绪

这题，最暴力的解法就是逐一轮回查找，但时刻复杂度是 n*n ，太暴力的不适合我们。
能够这么看，在遍历第一个值得时刻，保存这个值与target的差，然后在下次遍历中，看看是否是与保存的差值雷同，假如雷同，那末就能够找到我们想要的效果了。画个简朴的表格以下：

这样一来，就须要纪录差值，散列表这一数据组织就排上用处了，来看看百科关于散列表的引见：

散列表（Hash table，也叫哈希表），是依据关键码值(Key value)而直接进行接见的数据组织。也就是说，它经由过程把关键码值映射到表中一个位置来接见纪录，以加速查找的速率。这个映射函数叫做散列函数，寄存纪录的数组叫做散列表。

给定表M，存在函数f(key)，对恣意给定的关键字值key，代入函数后若能获得包括该关键字的纪录在表中的地点，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

而js中的对象就是基于哈希表组织，所以我们组织一个js对象即可，value是当前遍历到的值，key是其与目标值的差。

这是我的解法以下：

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function (nums, target) {
    let map = {};
    let result = []
    for (let index = 0;index <= nums.length;index++) {
        const val = nums[index];
        if (map[val] !== undefined) {
            result.push(map[val], index);
            break;
        }
        const a = target - val;
        map[a] = index
    }
    return result;
};

// nums = [2, 6, 3, 15], target = 9
// twoSum(nums,target)

两数相加

两数之和，问题形貌以下：

给出两个 非空 的链表用来示意两个非负的整数。个中，它们各自的位数是根据 逆序 的体式格局存储的，而且它们的每一个节点只能存储 一名 数字。

假如，我们将这两个数相加起来，则会返回一个新的链表来示意它们的和。

您能够假定除了数字 0 以外，这两个数都不会以 0 开首。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)

输出：7 -> 0 -> 8

缘由：342 + 465 = 807

我的思绪

看到这题，我的第一主意就是把链表的每一个节点的值合并成一个整形，然后在相加，末了在转换成链表，思绪异常简朴暴力。可等我写完，测试用例一跑，效果以下

缘由是 JavaScript 中Number的精度是16位，超过了就会涌现精读丧失，看来直接转换然后相加的体式格局不可啊，没紧要，那就用数组模仿大数相加。完全的步骤以下

1. 将多个 ListNode 组织变成二维数组
2. 把二维数组中的每一个下标对应的元素相加，从下标 0 最先相加，满十进一名，算是模仿大数相加的一种简朴体式格局，末了输出的是一维数组
3. 把一维数组转换成 ListNode 组织

我的解法以下

/**
 * 将多个ListNode组织变成二维数组，在盘算该二维数组各个节点的和
 * 如传入的两个ListNode对象 {val:2,next:{val:3,next:null}} {val:4,next:{val:5,next:null}}
 * 转成以下二维数组 [ [2,3], [4,5] ], 盘算两数组和 ，返回 [6,8]
 * @param  {...any} list 
 */
function addListNode(...list) {
    const valList = list.map((node) => {
        const list = [];
        while (node) {
            list.push(Number(node.val));
            node = node.next;
        }
        return list;
    })
    return arraySum(valList);
}
/**
 * 盘算数组的和
 * @param {*} list 
 */
function arraySum(list) {
    return list.reduce((result, item) => {
        return arrayItemSum(result, item);
    }, [])
}

/**
 * 盘算传入的数组的和
 * @param {Array} a 
 * @param {Array} b 
 */
function arrayItemSum(a, b) {
    let logArray = a;
    let sortArray = b;
    if (b.length > a.length) {
        logArray = b;
        sortArray = a;
    }
    let addOne = 0; //满十进一
    const result = logArray.reduce((result, val, index) => {
        const sum = (result[index] || 0) + val + addOne;
        addOne = 1;
        const mod = sum % 10;
        const div = sum / 10;
        if (div < 1) {
            result[index] = mod;
            addOne = 0;
        } else if (div > 1) {
            result[index] = mod;
        } else {
            result[index] = 0;
        }
        return result;
    }, sortArray)
    if(addOne){
        result.push(1);
    }
    if (!result[result.length - 1]) {
        result.pop(1)
    }
    return result;
}

/**
 * 数组构建成 ListNode 组织
 * @param {*} numList 
 */
function numToListNode(numList) {
    let preNode = undefined;
    return numList.reduce((result, val) => {
        let node = new ListNode(val);
        if (preNode) {
            preNode.next = node;
            preNode = node
        } else {
            result = preNode = node
        }
        return result
    }, new ListNode(0))
}
var addTwoNumbers = function (l1, l2) {
    return numToListNode(addListNode(l1, l2));
};

看完代码，人人是否是以为代码异常长，尤其是 arrayItemSum 这个乞降的函数，实在，这题考的是链表的操纵，但被我硬生生的把链表拆数组，末了变成了js怎样完成大数相加，手动狗头.jpg

我leetcode上看到个异常优异的解法，在递归中将每一个节点中的val相加，在将余数传入递归函数中，直到两个链表都遍历完成

var addTwoNumbers = function(l1, l2) {
    const addNumbers = (l1, l2, extra) => {
        let sum = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + extra;
        const node = new ListNode(sum % 10);
        let nl1 = l1 ? l1.next : null;
        let nl2 = l2 ? l2.next : null;
        if (nl1 || nl2 || sum > 9) {
            node.next = addNumbers(nl1, nl2, Math.floor(sum / 10))
        }
        return node;
    };
    return addNumbers(l1, l2, 0);
};

小结

刷leetcode一时苦，一向刷终会爽，加油ヾ(◍°∇°◍)ﾉﾞ