letcode刷题n7-q167：两数之和 II - 输入有序数组

题目描述

给定一个已按照 非递减顺序排列 的整数数组numbers ，请你从数组中找出两个数满足相加之和等于目标数target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。


示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]


提示：

2 <= numbers.length <= 3 * 104
-1000 <= numbers[i] <= 1000
numbers 按 非递减顺序 排列
-1000 <= target <= 1000
仅存在一个有效答案

思路 & CODE

1. 哈希

似乎这种查找元素的题目都能用哈希，但一般不是最优解，比较需要开辟额外的空间

首先把元素全部放到map里，之后再次遍历数组，只要map.get(target-当前元素)不为null，就把获取当前元素的索引。当然题目有要求i < j，所以这里还需要判断一下元素大小再返回

public int[] twoSum1(int[] numbers, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < numbers.length; i++) {
        map.put(numbers[i], i);
    }
    for (int i = 0; i < numbers.length; i++) {
        Integer index = map.get(target - numbers[i]);
        if (index != null) {
            if (i > index) {
                return new int[]{index+1, i+1};
            } else {
                return new int[]{i+1, index+1};
            }
        }
    }
    return new int[]{-1, -1};
}

时间复杂度O(n)，空间复杂度O(n)

2. 二分查找

由于题目给了条件，给的数组是递增的。那么我们遍历到一个元素，用target-这个元素获得另一个元素，再在该元素后面二分查找另一个元素即可。

public int[] twoSum2(int[] numbers, int target) {
    for (int i = 0; i < numbers.length; i++) {
        int left = i + 1;
        int right = numbers.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (numbers[i] + numbers[mid] == target) {
                return new int[]{i + 1, mid + 1}; 
            } else if (numbers[i] + numbers[mid] < target) {
                left = mid + 1;
            } else if (numbers[i] + numbers[mid] > target) {
                right = mid - 1;
            }
        }
    }
    return new int[]{-1, -1};
}

遍历需要n的时间，二分需要logn，所以时间复杂度为O(logn)

3. 双指针

写这道题目的时候就看了一下tag，虽然看到了有双指针，但是代入想了半天还是没想到解法。

看了题解，指针放在首位，每次循环计算首位指针元素和，小于target就把左指针右移；大于target就把右指针左移。while的条件是left < right。知道首尾指针和等于target就返回索引位置

这种解法让人疑惑的是，这样移动指针会不会漏掉元素？

看了题解发现了一个绝妙的思路！

就不重复记录了，可以看下方链接;简而言之，这道题里所有的元素组合都可以放到一个矩形里，这个矩形里有n^2个小矩形，每个小矩形就是一种元素组合。暴力循环每次可以排除掉一个小矩形，而双指针每次可以排除掉一行（列）的矩形

public int[] twoSum3(int[] numbers, int target) {
    int left = 0;
    int right = numbers.length - 1;
    while (left < right) {
        if (numbers[left] + numbers[right] == target) {
            return new int[]{left + 1, right + 1};
        } else if (numbers[left] + numbers[right] > target) {
            right--;
        } else if (numbers[left] + numbers[right] < target) {
            left++;
        }
    }
    return new int[]{-1, -1};
}