LeetCode 167. 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. Please note that 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.

Input:

numbers={2, 7, 11, 15}, target=9

Output:

index1=1, index2=2

分析问题：

输入一个有序数组，输入一个target值。求两个值的和等于target的下表的值。
一种做法是用两个下标从数组的两边开始进行向中间合拢，nums[left]+nums[right]> target 这个时候right–。如果 nums[left]+nums[right]< target 这个时候left++。

代码实现：

class Solution {
   public int[] twoSum(int[] numbers, int target) {
        int[] result = new int[2];
        if (numbers == null || numbers.length < 2) {
            return result;
        }
        int left = 0;
        int right = numbers.length - 1;
        while (left < right) {
            if (numbers[left] + numbers[right] > target) {
                right--;
            } else if (numbers[left] + numbers[right] < target) {
                left++;
            } else {
                result[0] = left + 1;
                result[1] = right + 1;
                return result;
            }
        }
        return result;
    }
}

改进：

如果用left++ 或者 right–，时间复杂度是O(n).由于数组是有序的，这个时候可以使用二分查找，将时间复杂度优化到O(lgn).

代码实现：

public int[] twoSum(int[] numbers, int target) {

        if (numbers == null || numbers.length < 2) {
            return new int[2];
        }

        int left = 0;
        int right = numbers.length - 1;

        while (left < right) {
            if (numbers[left] + numbers[right] == target) {
                return new int[]{left + 1, right + 1};
            } else if (numbers[left] + numbers[right] < target) {

                left = findEqualsOrLatestSmaller(numbers, left, right, target - numbers[right]);
            } else if (numbers[left] + numbers[right] > target) {

                right = findEqualsOrLatestGreater(numbers, left, right, target - numbers[left]);
            }

        }

        return new int[2];

    }

    /**
     * 找出当前系统中大于target最近的,或者和target相等的值
     *
     * @param numbers
     * @param left
     * @param right
     * @param target
     * @return
     */
    protected int findEqualsOrLatestGreater(int[] numbers, int left, int right, int target) {

        while (left <= right) {
            int mid = (left + right) / 2;
            if (numbers[mid] == target) {
                return mid;
            } else if (numbers[mid] > target) {
                right = mid - 1;
            } else if (numbers[mid] < target) {
                left = mid + 1;
            }


        }
        return right;
    }

    /**
     * 找出里 numbers中 left到right之间比target大的最近的值或者是相等的值
     *
     * @param numbers
     * @param left
     * @param right
     * @param target
     * @return
     */
    protected int findEqualsOrLatestSmaller(int[] numbers, int left, int right, int target) {

        while (left <= right) {
            int mid = (left + right) / 2;
            if (numbers[mid] == target) {
                return mid;
            } else if (numbers[mid] < target) {
                left = mid + 1;
            } else if (numbers[mid] > target) {
                right = mid - 1;
            }
        }
        return left;
    }

总结

在遇到有序的问题的时候，查找可以使用二分查找来加快收敛的过程。