力扣--＞#167. 两数之和II-输入有序数组--＞数组-中等(二分查找、双指针)

167. 两数之和 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 * 
-1000 <= numbers[i] <= 1000
numbers 按非递减顺序排列
-1000 <= target <= 1000
仅存在一个有效答案

解法一：双层for循环筛选遍历

最容易想到的解法，但只在找到第二个数值之后才退出循环，没有其他地方的优化，性能并不佳，有利用题目有序的性质，体现在找到第一个数值之后固定他，然后查找第二个数值时从该数的下一位开始查找而非从头寻找。

执行结果：
执行用时：419 ms, 在所有 Java 提交中击败了5.10%的用户
内存消耗：43.8 MB, 在所有 Java 提交中击败了23.89%的用户
通过测试用例：21 / 21

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int first=-1;
        int last=0;
        int flag=0;//还未找到第二个数
        for (int i=0;i<numbers.length;i++){//从头到尾遍历
            if (flag==1){
                break;
            }
            //此处不可为了减少判断次数而增加类似判断，为避免两数分别为两负数之和target为更小的负数的情况的误判
            //if (numbers[i]<=target){
                first=i+1;
                for (int j=i+1;j<numbers.length;j++){
                    //此处不可为了减少判断次数而增加类似判断，为避免两数分别为负数和0的情况的误判
                    // if (numbers[j]>target){
                    //     break;
                    // }
                    if (numbers[i]+numbers[j]==target){
                        last=j+1;
                        flag=1;
                        break;
                    }
                }
            //}
        }
        int[] result=new int[]{first,last};
        return result;
    }
}

解法二：二分查找

二分查找利用数组的有序性质，首先固定一个数，寻找第二个数，在数组中设置首位指针，这俩指针指示的是第二个数的范围，每次查找第二个数时，只在第一个数的右侧寻找（即下方第四行的注释），并判断目标值是否与此二数之和相等。

执行结果：通过
执行用时：4 ms, 在所有 Java 提交中击败了20.45%的用户
内存消耗：44.3 MB, 在所有 Java 提交中击败了5.10%的用户
通过测试用例：21 / 21

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for (int i=0;i<numbers.length;i++){//从头到尾遍历
            //注意此处low=i+1而非0，因为第一个比较的i已经为0了，所以应从i的下一位开始
            int low=i+1,high=numbers.length-1;
            while (low<=high){
                int mid=(high-low)/2+low;
                if (target==numbers[i]+numbers[mid]){
                    return new int[]{i+1,mid+1};//注意此处返回索引值
                }else if (target<numbers[i]+numbers[mid]){
                    high=mid-1;
                }else {
                    low=mid+1;
                }
            }
        }
        return new int[]{-1,-1};
    }
}

若不用low=i+1则需要增加一个判断mid是否等于i，若相等则需使mid=i+1，以避免重复取得同一个值，导致类似[1,2,3,4,4,9,56,90]，8 的测试用例无法通过，代码如下图第8行代码

 解法三：双指针

设置两个首尾指针，是这两个指针相加，若和等于target，则得到唯一解；若和大于target，则右指针左移；若和小于target，则左指针右移，最终求得唯一解。

不存在错过唯一解：由于解唯一，所以在指针移动的过程中，除非初始位置就得到最终解，否则肯定会有左指针先到达最终的i（因为到达时必定和大于target，需要右指针左移）或右指针先到达最终的j（同理），所以并不会错过唯一解。

执行结果：通过
执行用时：1 ms, 在所有 Java 提交中击败了72.70%的用户
内存消耗：44.5 MB, 在所有 Java 提交中击败了5.10%的用户
通过测试用例：21 / 21

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int low=0;
        int high=numbers.length-1;
        while (low<high){
            if (numbers[low]+numbers[high]==target){
                return new int[]{low+1,high+1};
            }else if (numbers[low]+numbers[high]<target){
                low++;
            }else {
                high--;
            }
        }
        return new int[]{-1,-1};
    }
}

平平无奇小白程序媛一枚，欢迎各位大佬交流指教，如有不正确的地方，欢迎留言改正，谢谢！！！