167.two-sum-ii-input-array-is-sorted

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:
返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例:

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

解法一: 暴力求解法
对于初学者来说，没有接触过双指针相关的问题，依然是首先会想到暴力求解的方法

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for(int i = 0; i < numbers.length; i++) {
            for(int j = i + 1; j < numbers.length; j++) {
                if(numbers[i] + numbers[j] == target) {
                	// 注意返回的下标是从1开始，所以都需要加1
                    return new int[]{i + 1, j + 1};
                }
            }
        }
        return null;
    }
}

本算法时间复杂度为O(n^2)（双重循环）,空间复杂度为O(1)（只有变量i和j是新开辟的空间）
解法二:HashMap求解
对于一些了解HashMap这种数据结构的同学，很容易能想到利用HashMap来求解，也就是和LeetCode第一题TwoSum相同的解法

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < numbers.length; i++) {
            // map.put(numbers[i], i); //如果放在这里可能会覆盖相同的key
            if(map.containsKey(target - numbers[i])) {
                int j = map.get(target - numbers[i]);
                if(i != j) {
                	//只是在这里进行了修改
                    return new int[]{j + 1, i + 1};   
                }
            }
            map.put(numbers[i], i); //注意只能放在这里，不能放在前面
        }
        return null;
    }
}

算法时间复杂度为O(n)(最坏情况下遍历整个数组，map的访问时间复杂度为O(1))，空间复杂度为O(n)(map的空间).
解法三:使用双指针
对于熟悉双指针的同学来说，其实本题很明显可以设置两个变量来分别从左往右及从右往左进行遍历。

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i = 0; 
        int j = numbers.length - 1;
        while(true) {
            if(i == j) {
                return null;
            }
            if(numbers[i] + numbers[j] == target) {
                return new int[] {i + 1, j + 1};
            }
            else if(numbers[i] + numbers[j] < target) {
            	// 如果两数之和小于target,必然只能增加numbers[i]的值，反映在有序数组上也就是i++
            	// 能不能增加numbers[j]的值？ 当然不能，j是从最右端往最左端进行进行滑动的，j右边
                // 的值已经被判断不满足条件
                i++; 
            } else {
            	// 如果两数之和小于target,必然只能减小numbers[j]的值，反映在有序数组上也就是j--
            	// 同理，当然不能缩小numbers[i]的值
                j--;
            }
        }
    }
}

算法时间复杂度为O(n)(最坏情况下遍历一遍整个数组)，空间复杂度为O(1)(只开辟了几个变量的存储空间)
解法四:二分查找法
对于本问题，有同学可能会想到，根据数组的有序性，我们可以先确定其中一个元素numbers[i]，再在数组中寻找target - numbers[i]，这样在寻找target - numbers[i]时就可以采用二分查找法来进行查找：

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for(int i = 0; i < numbers.length; i++) {
            // 在数组中查找target - numbers[i]
            int left = 0;
            int right = numbers.length - 1;
            while(left <= right) {
                int mid = (left + right) / 2;
                //注意防止重复元素
                if(numbers[mid] == target - numbers[i] && mid != i) {
                    if(i > mid) {
                        int temp = i;
                        i = mid;
                        mid = temp;
                    }
                    return new int[] {i + 1, mid + 1};
                } else if(numbers[mid] < target - numbers[i]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return null;
    }
}

上述算法在查找target-numbers[i]时是一个典型的二分查找法，二分查找的时间复杂度为O(logn)，因此，我们的算法最终时间复杂度为O(nlogn)，虽然比上述两种算法要慢，但相比暴力求解法，依然快了非常多。空间复杂度为O(1)(只开辟了变量的存储空间)。
总结: 本题是一道经典的双指针问题，值得进行总结。