LeeCode - 两数之和

题目：

给定一个整数数组 nums和一个目标值target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    
};

分析：

我第一时间想到的是暴力双for循环，时间复杂度为O(n^2）。

第一次答案：

var twoSum = function(nums, target) {
    var arr = []
    for (i = 0; i < nums.length - 1; i ++) {
        for (j = i + 1; j < nums.length; j ++) {
            if (nums[i] + nums[j] == target) {
                arr.push(i, j)
            }
        }
    }
    return arr
}

这里 j不应该小于nums.length - 1，会导致无法取到数组最后一位，当需要取得数组最后一位时，会返回错误的数组。

第二次答案：

var twoSum = function(nums, target) {
    var arr = []
    for (i = 0; i < nums.length - 1; i ++) {
        for (j = i + 1; j < nums.length; j ++) {
            if (nums[i] + nums[j] == target) {
                arr.push(i, j)
            }
        }
    }
    return arr
}

结果：提交成功

耗时：300ms

内存：34.6MB

其他解法：

leetcode-cn.com/problems/tw…

创建一个Map()，将要比较的数组中每个数所在的位置和数用Map数据结构存储起来，然后使用for循环来和map里面的数据进行比较，这里要注意一下，因为不能重复使用数组里面位置相同的数字，必须要对比一下map里面存储的位置与当前比较的数字的位置是否相同

var twoSum = function(nums, target) {
    let map = new Map();
    let arr = new Array()
    for(let i in nums){
        map.set(
            nums[i],
            i
        )
    }
    
    for(let j = 0; j < nums.length - 1; j++){
        if(map.has( target - nums[j] ) && map.get( target - nums[j]) != j ){
            arr.push( j , map.get( target - nums[j] ) );
            return arr
        }
    }

}

2. 边存边比较

非常简洁的一个方法，原理是先创建一个json空数组，以键值对的方式存储位置和对应的数字，然后for循环给的数组，当前数字不符合要求就存入json，然后再次比较，直到得到正确答案

var twoSum = function(nums, target) {
   const map = {}
   for (let i = 0; i < nums.length; i++){
       if(map[target - nums[i] ] >= 0){
           return [ map[target - nums[i] ], i]
       }
       map[nums[i]] = i;            
    }

}

3. 将方法 2 改成尾递归的形势

执行速度比方法3快了40ms左右，记得使用尾递归优化

var twoSum = function(nums, target, i = 0, maps = {}) {
    const map = maps
        if(map[target - nums[i] ] >= 0 ) {
            return [ map[target - nums[i] ], i]
        } else {
            map[ nums[i] ] = i;
            i++;
            if(i < nums.length - 1){
                return twoSum(nums, target, i, map)
            }else {
                throw 'error: twoSum is not find'
            }
        }
}