LeetCode167.Two Sum II - Input array is sorted题解

1. 题目描述

Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number. The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based. You may assume that each input would have exactly one solution and you may not use the same element twice.

2. 样例

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

3. 分析

题目描述的很清楚，就是给了一个已经按照升序排列的数组和一个目标值target，我们需要做的任务是在这个数组中找到一对元素的下标，使两个元素之和为target，并且题目已经限定了条件，给定的数组有且只有一对满足条件。
这样就大大缩小了题目的难度。我这里提供了3种方法，其中第一种因为时间复杂度为O(n^2)且没有通过优化，提交的时候直接超时了，第二种是在第一种基础之上做了部分优化，第三种则直接是复杂度为O(n)。

3.1. 方法1 直接二层循环

最直接的就是两层循环，每个元素都和后面的元素相加判断与target是否相等，这种算法很容易想，实现简单，但是时间复杂度为O(n^2)，在多个大规模数据的测试样例下直接超时，如下图所示：

所有测试样例都过了，证明结果正确，但是卡在了最后那个很多测试数据的样例中，说明两层循环嵌套时间太长。

3.2. 方法2 优化后的二层循环

由于数组是排好序的，我们知道如果当前数组元素numbers[i]要大于等于target的值，那么后面的肯定更大，它们都不会成为结果。于是我们首先先进行判断，将这部分的元素去掉。这种思想是第一种算法的一个优化，好处是参与二层循环遍历的数组元素个数不会那么多，可以节约时间，勉强通过了测试。如图：

3.3. 方法3 左右扫描

这种做法类似快速排序的思想：从数组的左右两边同时开始扫描，如果当前两个元素之和等于target，则直接返回结果；如果之和大于target，则说明右边的元素可能比较大，右边的下标向左移动；同理，如果之和小于target，则说明左边的元素可能比较小，左边的下标向右移动。

4. 源码

4.1. 方法1 直接二层循环

这个是未通过测试的错误代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> result;
        if (numbers.size() <= 1) {
            return {};
        }

        bool isFind = false;
        for (int i = 0; i < (int)numbers.size(); i++) {
            if (isFind == false) {
                for (int j = i+1; j < (int)numbers.size(); j++) {
                    if (numbers[i] + numbers[j] == target) {
                        result.push_back(i+1);
                        result.push_back(j+1);
                        isFind = true;
                        break;
                    }
                }
            }
            else {
                break;
            }
        }
        return result;
    }
};

4.2. 方法2 优化后的二层循环

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> result;

        int pos = -1;
        for (int i = 0; i < (int)numbers.size(); i++) {
            if (numbers[i] >= target) {
                pos = i + 1;
                break;
            }
        }
        if (pos == -1) {
            pos = numbers.size();
        }
        bool isFind = false;
        for (int i = 0; i < pos; i++) {
            if (isFind == false) {
                for (int j = i+1; j <= pos; j++) {
                    if (numbers[i] + numbers[j] == target) {
                        result.push_back(i+1);
                        result.push_back(j+1);
                        isFind = true;
                        break;
                    }
                }
            }
            else {
                break;
            }
        }
        return result;
    }
};

4.3. 方法3 左右扫描

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> result;
        int left = 0, right = numbers.size()-1;
        while(left != right) {
            if (numbers[left] + numbers[right] == target) {
                result.push_back(left+1);
                result.push_back(right+1);
                break;
            }
            else if (numbers[left] + numbers[right] > target) {
                right--;
            }
            else {
                left++;
            }
        }
        return result;
    }
};

5. 心得

这道题目不难，但是对三种方法进行对比，积累了巧妙算法的思路。