给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。
函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2*。*
说明:
- 返回的下标值（index1 和 index2）不是从零开始的。
- 你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例:
输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。解题思路
首先想到的解决思路是通过两次循环，每次循环遍历列表，这种算法的时间复杂度是O(n^2)。（这是我们在Leetcode 1 两数之和中提到的解决方案）
class Solution:
def twoSum(self, numbers, target):
"""
:type numbers: List[int]
:type target: int
:rtype: List[int]
"""
nums_len = len(numbers)
for i in range(nums_len):
for j in range(i + 1, nums_len):
if numbers[i] + numbers[j] == target:
return [i + 1, j + 1]
return []但是很明显，这种暴力解法在这问题中显得很蠢(⊙﹏⊙)
我们知道这个数据是有序的，那么我们很容易联想到使用二分搜索法是不是可以用于这个问题呢？我们可以每次判断target-num[i]对应的值是否在num[i+1:]中，这个时候算法的复杂度变成了O(nlogn)。
class Solution:
def _BinarySearch(self, numbers, target):
l = 0
r = len(numbers) - 1
while l <= r:
mid = (l + r) // 2
if target == numbers[mid]:
return mid
elif target < numbers[mid]:
r = mid - 1
else:
l = mid + 1
return -1
def twoSum(self, numbers, target):
"""
:type numbers: List[int]
:type target: int
:rtype: List[int]
"""
nums_len = len(numbers)
for i in range(nums_len):
dif = target - numbers[i]
dif_index = self._BinarySearch(numbers[i + 1:], dif)
if dif_index != -1:
return [i + 1, dif_index + i + 2]
return []那么我们就想有没有O(n)级别的做法呢？我们依然可以参考之前Leetcode 1 两数之和中使用hash表的方法，但是这种做法的空间复杂度就变成了O(n)。我们有没有空间复杂度O(1)，时间复杂度O(n)的做法呢？我们要充分利用题目给的条件：有序数组
0 1 2 3 4 5 6 7
l-> <-r我们可以这样想，我们首先判断首尾两项的和是不是target，如果比target小，那么我们左边+1位置的数（比左边位置的数大）再和右相相加，继续判断。如果比target大，那么我们右边-1位置的数（比右边位置的数小）再和左相相加，继续判断。我们通过这样不断放缩的过程，就可以在O(n)的时间复杂度内找到对应的坐标位置。（这和快速排序的思路很相似）
class Solution:
def twoSum(self, numbers, target):
"""
:type numbers: List[int]
:type target: int
:rtype: List[int]
"""
l = 0
r = len(numbers) - 1
while l < r:
if numbers[l] + numbers[r] == target:
return [l + 1, r + 1]
elif numbers[l] + numbers[r] < target:
l += 1
else:
r -= 1
return []这种解法叫做对撞指针法，又叫做双索引法。
该问题的其他语言版本添加到了我的GitHub Leetcode
如有问题，希望大家指出！！！