LeetCode 167.两数之和 II-输入有序数组(双指针+二分查找)

题目链接：LeetCode 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 * 104
-1000 <= numbers[i] <= 1000
numbers 按 非递减顺序 排列
-1000 <= target <= 1000
仅存在一个有效答案

题目分析：

最初我以为给的数组是严格递增的，然后用下面的代码提交后在最后一个测试案例中超时了（最后一个测试案例确实恶心，前面一大堆-1，最后两个1，target为2）

超时代码（c++）：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int length=numbers.size();
        int j=length-1,l=0,k=0;
        for(int i=0;i<length;i++)
        {
            if(numbers[i]>target)
            {
                j=i-1;
                break;
            }
        }
        for(l=0;l<j;l++)
        {
            for(k=l+1;k<=j;k++)
            {
                if(numbers[l]+numbers[k]==target)
                {
                   return {l+1,k+1};
                }
            }
        }
        return {-1,-1};
    }
};

想了想这代码确实不行，只处理了上限，没有处理数据下限，然后我想在这个的基础上使用二分查找。

二分查找

 拿示例一来分析一下：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]

我们先从第一个数据 2 开始，然后在用 目标值（target）减去该数据 得到我们所要查找的关键值 7

，然后再在[7,11,15]（后面的数据）中使用二分查找来查找关键值。

 二分代码（c++）:

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int length=numbers.size();
        int left=0,right=length-1;
        for(int i=0;i<length;i++)
        {
            left=i+1;
            while(left<right)
            {
                int mid=right-(right-left)/2;
                if(numbers[mid]==target-numbers[i])//关键值比对
                    return {i+1,mid+1};
                if(numbers[mid]>target-numbers[i])
                    right=mid-1;
                else
                    left=mid+1;
            }
            if(numbers[left]==target-numbers[i])
                    return {i+1,left+1};
        }
        return {-1,-1};
    }
};

这样的平均时间复杂度为O(nlogn)（for循环的n*二分的logn），我们用双指针来减小时间复杂度。

双指针

还是拿示例一来分析一下：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]

同样从第一个数据 2 开始，但是这时候我们和 最后一个数据 15 相加，然后将得到的值 17 和目标值比对，如果大于目标值则说明应该在前面的数据 [2,7,11] 中寻找，接下来将第一个不变的数据和改变后当前数组中的最后一个数据相加（后面的指针向前移动），否则在后面的数据中寻找，将第二个数据和最后一个数据相加(前面的指针向后移动)。重复上述过程，两个指针不断靠近直至碰撞（两指针指向的数据为同一个），在此期间我们就能找到所要输出的数组下标值，最后将其+1后输出答案。

双指针代码（c++）:

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

双指针+二分查找

在双指针的基础上使用二分查找来加快两个指针的移动速度。

代码（c++）：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int length=numbers.size();
        int left=0,right=length-1;
        while(left<right)
            {
                int mid=right-(right-left)/2;
                if(numbers[left]+numbers[mid]>target)//如果左边的值加上中间值比目标值还大证明后面的指针所指向的值应该在中间值的左区间内
                    right=mid-1;
                if(numbers[mid]+numbers[right]<target)//如果右边的值加上中间值比目标值还小证明前面的指针所指向的值应该在中间值的右区间内
                    left=mid+1;
                if(numbers[left]+numbers[right]==target)
                    return {left+1,right+1};
                if(numbers[left]+numbers[right]>target)
                    right--;
                if(numbers[left]+numbers[right]<target)
                    left++;
            }
        return {-1,-1};
    }
};

 计算机204 zjr