【LeetCode】167. Two Sum II - Input array is sorted

LeetCode 167传送门

三种解法：

1. Brute Force，时间复杂度，空间复杂度

    遍历嵌套遍历，时间复杂度高，且没有利用到列表有序这一有利条件。

2. 二分法查找，时间复杂度，空间复杂度

    遍历列表元素ele，在未遍历的列表元素中查找是否存在target-ele，查找采用二分查找法。

3. 两个指针，时间复杂度，空间复杂度

    初始化两个指针，分别指向数组的第一个元素和最后一个元素。当左指针不等于右指针时，循环：比较（左指针指向元素+右指针指向元素）之和与target的关系，若相等，返回左右指针index；若小于，左指针向右移动一位；若大于，右指针向左移动一位。

Python源码：

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        # assume one solution exists, and input array is sorted
        left = 0
        right = len(numbers) - 1
        while(numbers[left] + numbers[right] != target):
            sum = numbers[left] + numbers[right]
            if sum > target:
                right -= 1
            elif sum < target:
                left += 1
        return [left+1, right+1]

我的心路：

    我采用了二分查找的方法，二分法的实现浪费了一些时间。取得成绩不好，为

Runtime: 68 ms, faster than 9.08% of Python online submissions for Two Sum II - Input array is sorted.

Memory Usage: 12.5 MB, less than 14.54% of Python online submissions forTwo Sum II - Input array is sorted.

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(numbers) - 1):
            tar_tmp = target - numbers[i]
            left = i + 1
            right = len(numbers) - 1
            if numbers[left] == tar_tmp:
                return [i+1, left+1]
            elif numbers[right] == tar_tmp:
                return [i+1, right+1]
            while left < right - 1:
                middle = (left + right) // 2
                if numbers[middle] < tar_tmp:
                    left = middle + 1
                    if numbers[left] == tar_tmp:
                        return[i+1, left+1]
                elif numbers[middle] > tar_tmp:
                    right = middle - 1
                    if numbers[right] == tar_tmp:
                        return[i+1, right+1]
                elif numbers[middle] == tar_tmp:
                    return [i+1, middle+1]

我的方法判断了过多相等关系，二分法的一种较好写法如下（来自wikipedia）：

def bsearch(nums, target):
    left = 0
    right = len(nums) - 1
    while(left <= right):
        m = (left + right) // 2
        if(nums[m] > target):
            right = m - 1
        elif(nums[m] < target):
            left = m + 1
        else:
            return m
    return -1