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

最新推荐文章于 2022-05-28 21:10:57 发布

原创最新推荐文章于 2022-05-28 21:10:57 发布 · 203 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#两数之和 #双指针法 #二分查找 #有序数组

LeetCode 专栏收录该内容

142 篇文章

订阅专栏

本文详细解析了两数之和II-输入有序数组的算法问题，包括暴力解法、二分查找法及双指针法，对比了各种方法的时间复杂度，提供了清晰的代码示例。

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

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

函数应该返回这两个下标值 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) {
        int []temp=new int[2];
        int i,j,k=0;
        for(i=0;i<numbers.length;i++){
            for(j=i+1;j<numbers.length;j++){
                if(numbers[i]+numbers[j]==target){
                    //返回的下标值（index1 和 index2）不是从零开始的，需要+1
                    temp[k]=i+1;
                    k++;
                    temp[k]=j+1;
                }
            }
        }
        return temp;
    }
}

通常，在面试过程中，面试官会让你想时间复杂度更小的算法。
由于该题目是有序数组，可以使用二分查找算法解题，但是如果使用双指针收敛查询会更快。

二分查找法

class Solution {
    public int[] twoSum(int[] numbers, int target) {
	       //有序数组-----二分查找法
        int i;
        int result[]=new int[2];
        for(i=0;i<=numbers.length-1;i++){
            int temp=binarySearch(numbers,i+1,numbers.length-1,target-numbers[i]);
            if(temp>=0){
                return new int[]{i+1,temp+1};
            }
            
        }
        return result;
    }
    public int binarySearch(int [] n,int l,int r,int t){
        int mid;
        while(l<=r){
            mid=l+(r-l)/2;
            if(n[mid]==t){
                return mid;
            }
            if(t<n[mid]){
                r=mid-1;
            }
            if(t>n[mid]){
                l=mid+1;
            }
        }
        //表示没有找到目标数
        return -1;
    }
}

复杂度分析：

二分查找法 O(nlogn)

双指针法思路：

由于是有序数组（递增或递减），使用指针对撞法（又叫双索引法），首先判断数组首尾元素之和时候与target值相等，如果和比target小，左指针+1，否则右指针-1…如此循环，直到找到两数之和等于target，或者指针相撞程序结束，这样程序只遍历了一遍数组元素，算法的时间复杂度为O(n)。（实现思路和快速排序相似）

class Solution {
    public int[] twoSum(int[] numbers, int target) {
	//有序数组-----双指针法
        int i=0,j=numbers.length-1;
         int []temp=new int[2];
        while(i<j){
            if(numbers[i]==target-numbers[j]){
                return new int []{i+1,j+1};
            }
            if(numbers[i]+numbers[j]<target){
                i++;
            }
            if(numbers[i]+numbers[j]>target){
                j--;
            }
        }
         throw new IllegalArgumentException("No two sum solution");
    }
}

复杂度分析：

双指针法 O(n)