Leetcode1、两数之和 方法总结（Java）_leetcode1.两数之和java

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 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 <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
H₂O is是液体。
2¹⁰ 运算结果是 1024.

法一：暴力穷举

此方法就是最简单的暴力穷举法了，也是新手博主本人最快想到的办法555，时间复杂度仍然是O(n^2)，空间复杂度O(1)。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if(nums[j] == target - nums[i]) {
                return new int[] {i, j};
            }
        }
    }
    return new int[] {};
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

法二：哈希法一

利用哈希表一一对应的原则，这边要特别注意一边遍历一边查找，否则对于[3,3]这样的测试用例没有办法判断，containsKey函数只能知道有没有包含对应的数字但不能知道有几个也不能指定第几个。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();//新建哈希映射表
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(target - nums[i])) {//看哈希表中是否包含
                return new int[]{i, map.get(target - nums[i])};
            }
            map.put(nums[i], i);//一边遍历一遍将当前数组数放入哈希表
            //防止先放入哈希表中有多个相同的数都同时存在
        }
        return new int[]{};
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

法三：哈希法二

两边分别用左右指针遍历，既不会有两个相同的数无法检测的情况，时间复杂度又减小了很多。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        if(nums == null || nums.length < 2) {
        return new int[] {};
    }
    Map<Integer, Integer> map = new HashMap<>();
    int left = 0;
    int right = nums.length - 1;
    while(left <= right) {
        int leftnum0 = nums[left];
        int rightnum0 = nums[right];
        int leftnum1 = target - leftnum0;
        int rightnum1 = target - rightnum0;
        if(map.containsKey(leftnum1)) {
            return new int[] {left, map.get(leftnum1)};
        }//是否有和leftnum相加为target的数，若左边扫描到该数直接返回
        else {
            map.put(leftnum0, left++);
        }//比较左边的下一个数
        if(map.containsKey(rightnum1)) {
            return new int[] {right, map.get(rightnum1)};
        }//是否有和rightnum相加为target的数，若右边扫描到该数直接返回
        else {
            map.put(rightnum0, right--);
        }//比较右边的下一个数
    }
    return new int[] {};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

三种方法效率对比