LeetCode刷题笔记（Two Sum II - Input array is sorted）

该题其实是前几天准备刷的题，当时由于时间不够没来及的编完，今天编完并经过一番调试后，提交也取得了很好的效果。整体感觉不算太难，下面就来具体分享一下该题的解法。

具体题目如下：

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.

Note:

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.
Example:

Input: numbers = [2,7,11,15], target = 9
Output: [1,2]
Explanation: The sum of 2 and 7 is 9. Therefore index1 = 1, index2 = 2.

 

题意分析：

给定一个有序（从小到大）数组和一个目标值，返回数组中之和等于目标值的两个数的索引（索引=调用下标+1）。很容易想到暴力法，两层for循环肯定能解决问题，但是这样做肯定不是题目想考察的，且该方法的时间复杂度为O(n*n)。

解答如下：

方法一

结合之前学过的二分搜索方法（原理请自行百度，网上很多），显然可以把计算复杂度降到O(nlogn)，空间复杂度O(n)，所以下面就利用二分搜索算法来解决本问题。第一层for循环用于将数组中第一数开始固定，进而配合二分搜索算法，不断的固定，直到满足条件为止。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int>nums={0,0};//因为返回值要求是向量，所以必须得创建一个向量去装索引
        for (int i = 0; i < numbers.size(); i++) { 
            int l = 0, r = numbers.size()-1; //二分搜索算法开始
            while(l <= r){   //二分搜索算法这里一般是while
                int mid = l+ (r-l)/2;  //避免了使用加法，因为加法容易产生溢出
                if( target - numbers[i] == numbers[mid] && mid != i) // 加上mid != i这个条件是为了避免同一个数被加两次，致使返回的索引一样。
                {
                    nums[0]=i+1;
                    nums[1]=mid+1;
                    return nums;}
                if( target - numbers[i] < numbers[mid])//更新边界
                    r = mid - 1;
                else
                    l = mid + 1;
            }

        }
        return nums; }
};

提交后的结果如下：

 

方法二

通过优化方法一中的代码，方法二给出了比较完善的二分搜索代码。该方法的时间复杂度O(nlogn)，空间复杂度O(1)。

优化点：①固定过的数，在下次二分搜索中不需要考虑。②增加了一些断言，使得程序的鲁棒性更强。

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

        assert(numbers.size() >= 2);
        assert(isSorted(numbers));

        for(int i = 0 ; i < numbers.size() - 1 ; i ++){
            int j = binarySearch(numbers, i+1, numbers.size()-1, target - numbers[i]);//固定过的数，在下次二分搜索中不需要考虑。
            if(j != -1){
                int res[2] = {i+1, j+1};
                return vector<int>(res, res+2);//将数组转成向量输出
            }
        }

        throw invalid_argument("the input has no solution");//如果目标值不是数组中两数之和则返回该句
    }

private:
    int binarySearch(const vector<int> &nums, int l, int r, int target){

        assert(l >= 0 && l < nums.size());
        assert(r >= 0 && r < nums.size());

        while(l <= r){

            int mid = l + (r - l)/2;
            if(nums[mid] == target)
                return mid;
            if(target > nums[mid])
                l = mid + 1;
            else
                r = mid - 1;
        }

        return -1;
    }

    bool isSorted(const vector<int>& numbers){
        for(int i = 1 ; i < numbers.size() ; i ++)
            if(numbers[i] < numbers[i-1])
                return false;
        return true;
    }
};

提交后的结果如下：

方法三

用对撞指针法，将有序数组（从小到大）两端分别用一个索引，当两索引指向之数的和大于目标值时，则右端索引向左移动（减小右端值）；当两索引指向之数的和小于目标值时，则左端索引向右移动（增大左端值）。该方法时间复杂度O(n)，空间复杂度O(1)。

class Solution {

public:
vector<int> twoSum(vector<int>& numbers, int target) {

    assert(numbers.size() >= 2);
    assert(isSorted(numbers));

    int l = 0, r = numbers.size() - 1;
    while(l < r){

        if(numbers[l] + numbers[r] == target){
            int res[2] = {l+1, r+1};
            return vector<int>(res, res+2);
        }
        else if(numbers[l] + numbers[r] < target)
            l ++; //左端指针增大
        else // numbers[l] + numbers[r] > target
            r --; //右端指针减小
    }

    throw invalid_argument("the input has no solution");//C++中的异常语句
}

private:
bool isSorted(const vector<int>& numbers){
    for(int i = 1 ; i < numbers.size() ; i ++)
        if(numbers[i] < numbers[i-1])
            return false;
    return true;
 }

};

提交后的结果如下：

日积月累，与君共进，增增小结，未完待续。