剑指 Offer II 006. 排序数组中两个数字之和（Java）

题目：

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

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

假设数组中存在且只存在一对符合条件的数字，同时一个数字不能使用两次。

示例 1：

输入：numbers = [1,2,4,6,10], target = 8
输出：[1,3]
解释：2 与 6 之和等于目标数 8 。因此 index1 = 1, index2 = 3 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[0,2]

示例 3：

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

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/kLl5u1

思路：

解法一、暴力双层循环

        一层循环扫描一遍数组，对每个元素i，用target-i，然后二层循环判断是否有元素j=target-i，ans[] = [i, j]。

        时间复杂度O(n^2)，空间复杂度O(1)。

执行用时：342 ms, 在所有 Java 提交中击败了5.03%的用户

内存消耗：41.8 MB, 在所有 Java 提交中击败了34.40%的用户

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

解法二、二分查找

        和解法一类似，但是在固定第一个元素i的基础上，在i的右侧用二分法查找第二个元素i（利用了该数组的升序性质）。

         时间复杂度O(nlogn)（logn为二分查找所需时间），空间复杂度O(1)。

执行用时：3 ms, 在所有 Java 提交中击败了18.80%的用户

内存消耗：42 MB, 在所有 Java 提交中击败了13.07%的用户

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for(int i = 0; i < numbers.length; i++){
            //在第一元素i的右侧二分查找第二个元素
            int low = i + 1, high = numbers.length - 1;
            while(low <= high){
                int mid = (high - low) / 2 + low; //防止high+low溢出
                if(numbers[mid] == target - numbers[i]){
                    return new int[]{i, mid};
                //太大了，去前半块找
                }else if (numbers[mid] > target - numbers[i]){
                    high = mid - 1;
                //太小了，去后半块找
                }else {
                    low = mid + 1;
                }
            }
        }
        return new int[]{-1, -1};
    }
}

解法三、双指针

        充分利用题给信息，由于题目存在唯一解，所以初始时两个指针分别指向第一个和最后一个元素。每次计算两个指针指向的元素之和，<target则将左指针右移一位，>target则将右指针左移一位，=target即为答案。

        在整个移动过程中，左指针不可能移到 i 的右侧，右指针不可能移到 j 的左侧，因此不会把可能的解过滤掉。由于题目确保有唯一的答案，因此使用双指针一定可以找到答案。

        时间复杂度O(n)（两个指针移动的总次数最多为 n 次），空间复杂度O(1)。

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：41.7 MB, 在所有 Java 提交中击败了48.77%的用户

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int low = 0, high = numbers.length - 1;
        while(low < high){//双指针不交叉
            if(numbers[low] + numbers[high] == target){
                return new int[]{low, high};
            //和小了，左指针右移
            }else if(numbers[low] + numbers[high] < target){
                low++;
            // 和大了，右指针左移
            }else{
                high--;
            }
        }
        return new int[]{-1, -1};
    }
}