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

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

说明:

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

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

1、暴力，超时

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

2、双指针+滑动窗口+条件限制 AC

在做题提交的过程中发现了几处不容易想到的地方：
1、numbers中的元素是递增的，但是这个递增不是numbers[i]<numbers[i],而是numbers[i]<=numbers[i+1]
2、numbers中的元素有正有负，可能连续好几个都是0
3、一开始我想：首先找到小于等于target的元素个数，这样的话两个值只需要在这些元素中找就可以了，但是事实并非如此。
例如：target=0，numbers[]= {-3,3,.....},如果用numbers[i]<=target，显然只能到第一个元素，所以我又添加了一个限制条件：
(i>=1 && numbers[i-1]+numbers[i]==0)(因为观察的是两个元素相加的结果，所以这样肯定是对的)
所以根据思考之后的修改为：

for(int i=0;i<n;i++)
{if(numbers[i]<=target || numbers[i]==0 ||(i>=1 && numbers[i-1]+numbers[i]==0)){num_smaller_than_target++;}else{break;} 
}

之后只需要在0~num_smaller_than_target-1的范围内寻找两个数就可以了！
然后使用双指针，一开始L指向0，R指向num_smaller_than_target-1，并且保证L<R来循环
在循环过程中，时时注意sum = numbers[L]+numbers[R],
1、如果sum==target,说明我们已经找到值了，直接退出
2、如果sum<target，说明左值一定过小（右边界由于是从大到小缩减的，此时不做改变，因为也不确定右边界是大是小）
3、如果sum>target,说明右值一定过大，选择减少右值（由于左边界是从小到大的，此时不做改变，因为也不确定左边界是大是小）

class Solution {
public:vector<int> twoSum(vector<int>& numbers, int target) {int n = numbers.size();int flag=0;vector<int> res;int num_smaller_than_target=0;//首先找到小于等于target的元素个数for(int i=0;i<n;i++){if(numbers[i]<=target || numbers[i]==0 ||(i>=1 && numbers[i-1]+numbers[i]==0)){num_smaller_than_target++;}else{break;} }int L=0;int R=num_smaller_than_target-1;//两个指针从两边往中间缩while(L<R){int sum = numbers[L]+numbers[R];if(sum==target){res.emplace_back(L+1);res.emplace_back(R+1);break;}//当和小于目标，说明，左值肯定过小else if(sum<target){L++;}//当和大于目标，说明，右值肯定过大else {R--;}}return res;}
};

因为有要求：

所以我们来验证一下重复结果是否输出一致：

显然正确。

3、观看题解（吸取他人经验）

1、二分查找

在数组中找到两个数，使得它们的和等于目标值，可以首先固定第一个数，然后寻找第二个数，第二个数等于目标值减去第一个数的差。利用数组的有序性质，可以通过二分查找的方法寻找第二个数。为了避免重复寻找，在寻找第二个数时，只在第一个数的右侧寻找。

class Solution {
public:vector<int> twoSum(vector<int>& numbers, int target) {int n = numbers.size();int flag=0;for(int i=0;i<n;i++){int low = i+1;int high = n-1;while(low<=high){int mid = (high - low) / 2 + low;if (numbers[mid] == target - numbers[i]) {return {i + 1, mid + 1};}else if (numbers[mid] > target - numbers[i]) {high = mid - 1;} else {low = mid + 1;}}}return {};}
};

总结：有序序列，查找值固定的数，可以考虑二分查找优化

2、双指针

这是官方题解，和我一开始用的思路是一样的，即双指针。

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

而我做的一开始排除一些元素的方法好像没有对时间有很多优化。。。

3、双指针+二分查找

class Solution {
public:vector<int> twoSum(vector<int>& numbers, int target) {int low = 0, high = numbers.size() - 1;while (low <high) {int middle = (low+high)*0.5;//1、目标在middle左侧，重置highif(numbers[low]+numbers[middle]>target){high =middle-1;}//2、目标在middle右侧,重置lowelse if(numbers[high]+numbers[middle]<target){low = middle+1;}//3、重置lowelse if(numbers[low]+numbers[high]<target){low++;}//4、重置highelse if(numbers[low]+numbers[high]>target){high--;}//5、sum等于targetelse{return {low+1,high+1}; }}return {0,0};}
};

不知道为什么同样的思路，用java速度可以达到1ms，而c++却不行。