数组LeeCode1. 两数之和

Posted 2021-07-29 chenry777

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

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

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

题解一：暴力解法

简单粗暴些，两重循环，遍历所有情况看相加是否等于目标和，如果符合直接输出。

class Solution {
    // 解法1: 暴力解法
    public int[] twoSum(int[] nums, int target) {
        int[] ans = new int[2];
        for(int i = 0;i < nums.length;i++){
            for(int j = i + 1;j < nums.length;j++){
                if(nums[i] + nums[j] == target) {
                    ans[0] = i;
                    ans[1] = j;
                    return ans;
                } 
            }
        }
        return ans;
    }
}

时间复杂度：两层 for 循环，O（n²）

空间复杂度：O（1）

题解二、使用HashMap减少一次内循环

第二层 for 循环无非是遍历所有的元素，看哪个元素等于 sub ，时间复杂度为 O（n）。

有没有一种方法，不用遍历就可以找到元素里有没有等于 sub 的？

hash table ！！！

我们可以把数组的每个元素保存为 hash 的 key，下标保存为 hash 的 value 。

这样只需判断 sub 在不在 hash 的 key 里就可以了，而此时的时间复杂度仅为 O（1）！

需要注意的地方是，还需判断找到的元素不是当前元素，因为题目里讲一个元素只能用一次。

class Solution {
    // 解法2: hashmap减少一次内循环
    public int[] twoSum(int[] nums, int target) {
        int[] ans = new int[2];
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0;i < nums.length;i++){
                map.put(nums[i], i);
        }

        for(int i = 0;i < nums.length;i++){
            int sub = target - nums[i]; 
            if (map.containsKey(sub) && map.get(sub) != i){
                ans[0] = i;
                ans[1] = map.get(sub);
                return ans;
            }
        }

        return ans;
    }
}

时间复杂度：比解法一少了一个 for 循环，降为 O（n）

空间复杂度：所谓的空间换时间，这里就能体现出来， 开辟了一个 hash table ，空间复杂度变为 O（n）

题解三、合并解法二的2个for循环

看解法二中，两个 for 循环，他们长的一样，我们当然可以把它合起来。复杂度上不会带来什么变化，变化仅仅是不需要判断是不是当前元素了，因为当前元素还没有添加进 hash 里。

class Solution {
    // 解法三: 合并解法二的2个for循环
    public int[] twoSum(int[] nums, int target) {
        int[] ans = new int[2];
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0;i < nums.length;i++){
            int sub = target - nums[i]; 
            if (map.containsKey(sub)){
                ans[0] = i;
                ans[1] = map.get(sub);
                return ans;
            }
            map.put(nums[i], i);
        }

        return ans;
    }
}

总结

题目比较简单，毕竟暴力的方法也可以解决。唯一闪亮的点就是，时间复杂度从 O（n²）降为 O（n） 的时候，对 hash 的应用，有眼前一亮的感觉。