打卡——两数之和

两数之和

题目

作者：力扣 (LeetCode)

链接：https://leetcode-cn.com/leetbook/read/tencent/xxqfy5/

来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

• 2 <= nums.length <= 103
• 109 <= nums[i] <= 109
• 109 <= target <= 109
• 只会存在一个有效答案

思路

最开始的时候是使用一个 map 将 nums[i] 做为 map 的健和下标作为值，然后遍历这个 map 对象，用target减去当前值，将得到的值作为健查找map中是否存在对应的值，如果存在(不为 undefined 即存在)，那么将这两个对应的值作为结果返回

例如nums = [2,7,11,15], target = 9,会得到一个map对象,以 2，7，11，15作为健，对应的下标作为值

map = {
    2: 0,
    7: 1,
    11: 2,
    15: 3
}

再遍历map对象，遍历map['2']的时候,判断map[target - key]也就是map[${9 - Number('2')}]是否存在，同理类推

但是存在一个问题，如果存在类似这种的，nums = [3, 2, 4], target = 6,返回的会是[0, 0],所以稍微改了一下，使用index数组保存下标,value保存值，count保存数量，再用同样的思路进行求解，代码如下：

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    const map = {};
    nums.forEach((item, index) => {
        if (!map[item]) {
            map[item] = {
                value: item,
                index: [],
                count: 0
            };
        }
        map[item].index.push(index);
        map[item].count++;
    })
    let result = [];
    for (let key in map) {
        const otherNum = target - map[key].value;
        if (map[otherNum]) {
            if (otherNum === map[key].value && map[otherNum].count > 1) {
                result = map[otherNum].index;
                break;
            } else if (otherNum !== map[key].value){
                result = [...map[key].index, ...map[otherNum].index];
                break;
            }
        }
    }
    return result;
};

虽然最终的结果过了，但是执行时间只超过了8%的用户(同种语言对比)，所以发现自己的这种解法存在一定的问题，然后看了题解，再优化了一下

优化

思路还是一样的，使用一个map将 nums[i] 做为 map 的健和下标作为值，但是不是存好之后再去遍历，而是在存储map之前判断一次，如果存在(不为 undefined )，那么就说明找到了，就直接返回

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

至于为什么是不等于undefined,是因为下标可能为0,下标为0是无法进入if判断的