leetcode 1

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

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

示例:

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

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

我的解法：

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

执行用时: 72 ms

时间复杂度：O(n2)。

思路： 用target减去数组中的一个数得到cha，查询数组中是否有差cha，includes返回cha的下标

 

------------------------------------------------------------------------------------------------------------------------------------------

看一下别的大佬的解法：

利用数组减少查询时间
在暴力法中，内层循环查找差值很浪费时间，那么如何减少查询时间呢？利用数组就可以减少查询时间。
使用一层循环，每遍历到一个元素就计算该元素与 targettarget 之间的差值 difdif，然后以 difdif 为下标到数组temp中寻找，如果 temp[dif] 有值(即不是 undefinedundefined)，则返回两个元素在数组 numsnums 的下标，如果没有找到，则将当前元素存入数组 temptemp 中(下标: nums[i], Value: inums[i],Value:i) 。
时间复杂度：O(n)

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

执行用时: 56 ms

 

 

 

对应java中的

思路
标签：哈希映射
这道题本身如果通过暴力遍历的话也是很容易解决的，时间复杂度在 O(n2)
由于哈希查找的时间复杂度为 O(1)，所以可以利用哈希容器 map 降低时间复杂度
遍历数组 nums，i 为当前下标，每个值都判断map中是否存在 target-nums[i] 的 key 值
如果存在则找到了两个值，如果不存在则将当前的 (nums[i],i) 存入 map 中，继续遍历直到找到为止
如果最终都没有结果则抛出异常
时间复杂度：O(n)