算法第一题 两数之和

1. 两数之和

提示

给定一个整数数组 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
• 只会存在一个有效答案

• 第一种解法暴力枚举解法

使用2层 for 循环嵌套然后判断他们的和等于我们的target 这样虽然也能拿到结果但是我们的看下我们的运算复杂度是的o(n2) (o(n平方))

public int[] twoSumnew(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i+1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[]{i, j};
            }
        }
    }
    return new int[0]; // 未找到匹配项，返回空数组
}

测试用例

public static void main(String[] args) {
    Leetcode leetcode = new Leetcode();
    int[] nums = {2, 7, 11, 15};
    int[] result = leetcode.twoSum(nums, 9);
    System.out.println(java.util.Arrays.toString(result));
}

• 测试结果

• 第二种使用hashMap

使用hashMap 我们只需要for 循环一次那么我们的可以通过判断 target - x 是否存在我们的hapsMap 表里面 如果存在即反对对应数组的下标即可 这样写法的运算复杂度是o(n)

public int[] twoSum2(int[] nums, int target) {
    Map<Integer, Integer> hashMap = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int x = nums[i];
        if (hashMap.containsKey(target - x)) {
            return new int[]{hashMap.get(target - x),i};
        }
        hashMap.put(x, i);
    }
    return new int[0]; // 如果没有找到，返回空数组（根据需求可调整）
}

• 测试代码

public static void main(String[] args) {
    Leetcode leetcode = new Leetcode();
    int[] nums = {2, 7, 11, 15};
    int[] result = leetcode.twoSum2(nums, 9);
    System.out.println(java.util.Arrays.toString(result));
}

• 测试结果

• 第三种方式

我们第三种方式其实是第二种修改版 我个人觉得好阅读一点 也是通过hasHMap枚举 一层for 循环即可

public int[] twoSum3(int[] nums, int target) {
    if (nums.length <= 1) {
        return new int[0]; // 或者抛出异常，根据需求调整
    }

    Map<Integer, Integer> buffDict = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        if (buffDict.containsKey(nums[i])) {
            return new int[]{buffDict.get(nums[i]), i};
        } else {
            buffDict.put(target - nums[i], i);
        }
    }
    return new int[0]; // 未找到匹配项
}