LeetCode题解（Java）：167-两数之和 II - 输入有序数组

167. 两数之和 II - 输入有序数组

https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/

题目描述

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

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

说明：

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

示例：

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

解法一：暴力法

• 两层循环

class Solution {
     
    public int[] twoSum(int[] numbers, int target) {
     
        for (int i = 0; i < numbers.length - 1; i++) {
     
            for (int j = i + 1; j < numbers.length; j++) {
     
                if (numbers[i] + numbers[j] == target) {
     
                    return new int[]{
     i + 1, j + 1};
                }
            }
        }
        return new int[]{
     };
    }
}

• 时间复杂度：O(N^2)
• 空间复杂度：O(1)

解法二：哈希表

• 使用HashMap装入值和下标，并判断 target - numbers[i] 是否在 keys 中

class Solution {
     
    public int[] twoSum(int[] numbers, int target) {
     
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < numbers.length; i++) {
     
            int sub = target - numbers[i];
            if (map.containsKey(sub)) {
     
                int j = map.get(sub);
                if (i > j) {
     
                    return new int[]{
     j + 1, i + 1};
                } else {
     
                    return new int[]{
     i + 1, j + 1};
                }
            }
            map.put(numbers[i], i);
        }
        return new int[]{
     };
    }
}

• 时间复杂度：O(N)
• 空间复杂度：O(N)

解法三：双指针

• 两端指针向中间夹逼，左指针 + 右指针 = target 时得到解
• 左指针 + 右指针 > target 时，说明右指针过大，应该-1；反之则左指针+1

class Solution {
     
    public int[] twoSum(int[] numbers, int target) {
     
        int lo = 0, hi = numbers.length - 1;
        while (lo < hi) {
     
            if (numbers[lo] + numbers[hi] > target) {
     
                while (lo < --hi && numbers[hi] == numbers[hi + 1]);
            } else if (numbers[lo] + numbers[hi] < target) {
     
                while (++lo < hi && numbers[lo] == numbers[lo - 1]);
            } else {
     
                return new int[]{
     lo + 1, hi + 1};
            }
        }
        return new int[]{
     };
    }
}

• 时间复杂度：O(N)
• 空间复杂度：O(1)

解法四：二分查找

• 数组有序，可以联想到使用二分查找
• 先计算target - numbers[i] 的差值sub
• 然后在 [i + 1, number.length - 1]寻找sub

class Solution {
     
    public int[] twoSum(int[] numbers, int target) {
     
        for (int i = 0; i < numbers.length; i++) {
     
            int sub = target - numbers[i];
            int lo = i + 1, hi = numbers.length - 1;
            while (lo <= hi) {
     
                int mid = (lo + hi) >>> 1;
                if (numbers[mid] == sub) {
     
                    return new int[]{
     i + 1, mid + 1};
                } else if (numbers[mid] > sub) {
     
                    hi = mid - 1;
                } else {
     
                    lo = mid + 1;
                }
            }
        }
        return new int[]{
     };
    }
}

• 时间复杂度：O(NlogN)
• 空间复杂度：O(1)