zoukankan      html  css  js  c++  java
  • leetCode-Two Sum II

    Description:
    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.

    Example:

    Input: numbers={2, 7, 11, 15}, target=9
    Output: index1=1, index2=2 

    My Solution:

    class Solution {
        public int[] twoSum(int[] numbers, int target) {
            int index1 = 0;
            int index2 = 0;
            int len = numbers.length;
            int temp = target/2;
            for(int i = 0;i < len -1;i++){
                if(numbers[i] > temp){
                    break;
                }
                for(int j = i + 1;j < len;j++){
                    if((numbers[i] + numbers[j]) > target){
                        break;
                    }
                    if((numbers[i] + numbers[j]) == target){
                        index1 = i;
                        index2 = j;
                        return new int[]{index1 + 1,index2 + 1};
                    }
                }
            }
            return new int[]{index1 + 1,index2 + 1};
        }
    }
    
    
    Better Solution(方法1):
    
    class Solution {
        public int[] twoSum(int[] numbers, int target) {
            int[] indices = new int[2];
            if (numbers == null || numbers.length < 2) {
                return indices;
            }
            int left = 0, right = numbers.length - 1;
            while (left < right) {
                int v = numbers[left] + numbers[right];
                if (v == target) {
                    indices[0] = left + 1;
                    indices[1] = right + 1;
                    break;
                } else if (v > target) {
                    right--;
                } else {
                    left++;
                }
            }
            return indices;
        }
    }
    Best Solution(方法2):
    
    class Solution {
        public int[] twoSum(int[] numbers, int target) {
            if (numbers == null || numbers.length == 0) {
                return new int[2];
            }
            int start = 0;
            int end = numbers.length - 1;
            while (start < end) {
                if (numbers[start] + numbers[end] == target) {
                    return new int[]{start + 1, end + 1};
                } else if (numbers[start] + numbers[end] > target) {
                    // move end forward to the last value that numbers[end] <= target - numbers[start]
                    end = largestSmallerOrLastEqual(numbers, start, end, target - numbers[start]);
                } else {
                    // move start backword to the first value that numbers[start] >= target - numbers[end]
                    start = smallestLargerOrFirstEqual(numbers, start, end, target - numbers[end]);
                }
            }
            return new int[2];
        }
        private int largestSmallerOrLastEqual(int[] numbers, int start, int end, int target) {
            int left = start;
            int right = end;
            while (left <= right) {
                int mid = left + (right - left) / 2;
                if (numbers[mid] > target) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }
            return right;
        }
        private int smallestLargerOrFirstEqual(int[] numbers, int start, int end, int target) {
            int left = start;
            int right = end;
            while (left <= right) {
                int mid = left + (right - left) / 2;
                if (numbers[mid] < target) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            return left;
        }
    }

     
    方法1利用了数组nums递增的特点,设置两个指针,left和right,分别表示数组的开始和结尾,开始迭代,如果nums[left] + nums[right] > target,那么right左移,反之,left右移

    方法2对方法1的改进在于,方法一在做出判断时,只让left或者right往右移或者往左移一步,而方法2通过largestSmallerOrLastEqual()方法让right最大限度移动(如果找到则返回,如果没找到,那么对当前start,在nums中找不到

    nums[start] + nums[end] = target,于是用二分查找,将end置为可以target可以在nums中插入的位置的前一位,那么下次进入smallestLargerOrFirstEqual(),smallestLargerOrFirstEqual()与largestSmallerOrLastEqual()类似,

    只是换成了将start最大限度往右移。如此循环,找到nums[start] + nums[end] = target,返回。

    版权声明:本文为博主原创文章,未经博主允许不得转载。
  • 相关阅读:
    【JBPM4】创建流程实例
    【JBPM4】流程部署
    Table上下滚动
    oracle 导入dmp文件
    Win7下安装Oracle 10g
    【Hibernate3.3复习知识点二】
    通过IP地址和子网掩码计算主机数
    vue.js知识总结
    vue生产环境部署总结
    移动端上遇到的各种坑与相对解决方案
  • 原文地址:https://www.cnblogs.com/kevincong/p/7881379.html
Copyright © 2011-2022 走看看