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

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

题目概述

给定一个已按照 非递减顺序排列  的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

 
示例 1：

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

输入：numbers = [2,3,4], target = 6
输出：[1,3]
示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
 

提示：

	 2 <= numbers.length <= 3 * 10^4
	-1000 <= numbers[i] <= 1000
	numbers 按 非递减顺序 排列
	-1000 <= target <= 1000
	仅存在一个有效答案

算法思路:

1. 哈希表

• 利用哈希表来存储元素，key为数组的元素，value为元素所对应的序号
• 遍历数组，判断哈希表中是否存在目标数-当前数的元素，如果存在则说明满足关系 目标数 = 哈希表元素 + 当前数，返回当前数的下标与哈希表所对应的元素value的数组即可
• 如果遍历数组之后仍然未找到相关数，则说明没有两数之和等于目标数

代码实现:

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

复杂度分析:

• 时间复杂度：O(n)，其中n为数组nums的长度
• 空间复杂度：O(n)

2. 双指针

• 因为数组是递增的，所以左边的元素一定大于右边的元素
• 所以可以选择双指针，一个指针指向左边元素，一个指针指向右边元素
• 如果两边元素加起来小于目标元素，则说明左边的数小了，左指针应该指向下一个元素
• 反之说明右指针大于目标元素，则说明右边的数大了，右指针应该指向上一个元素
• 如果左右指针所指向的元素之和等于目标元素，则返回两指针所组成的数组
• 反之则返回空数组

代码实现:

public int[] twoSum(int[] numbers, int target) {
		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{
				return new int[]{left + 1,right + 1};
			}
		}
		return new int[0];
    }

复杂度分析:

• 时间复杂度：O(n)，其中n为数组nums的长度
• 空间复杂度：O(1)

3. 双指针+二分查找

• 因为数组是按照递增顺序排序的，所以可以先利用两个指针中间的数，分别与两指针相加后与目标值比较
• 如果中间的数与左指针所指的元素之和大于目标值，则说明右指针指向的数过大，应该更新右指针为中间位置的前一位数
• 相反，如果中间的数与右指针所指的元素之和小于目标值，则说明左指针指向的数过大，应该更新左指针为中间位置的后一位数
• 同时，在比较完之后，判断现在两指针之和与目标数的大小
• 如果两指针之和仍然小于目标数，则更新左指针指向后一位
• 反之，如果两指针之和仍然大于目标数，则更新右指针指向前一位
• 如果在左右指针相遇之后还未能找到结果，则返回空数组

代码实现:

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

复杂度分析:

• 时间复杂度：O(n)，其中n为数组numbers的长度，最好的情况为logn，最坏的为n
• 空间复杂度：O(1)