LeetCode 1.Two Nums

[Chinese ver]1.两数求和 。给定一个整数的数组，返回两个数字的索引使得这两个数字加起来成为一个指定的目标值。
你能够假设每一个输入都至少有一个解决方案，而且你不能使用相同的元素两次。

Example:

Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].复制代码

首先是一次错误的尝试

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] testNums = new int[nums.length];
        int j = 0;
        for (int i=0;i<nums.length;i++){
            if(nums[i]<target){
                testNums[j] = nums[i];
                j=j+1;
            }
        }
        for(int l=0;l<j;l++){
            for(int k=l+1;k<j;k++){
                if(testNums[l]+testNums[k]==target){
                    return new int[]{l,k};
                }
            }
        }
      return null; 
    }
}复制代码

出错啦！！

没理解好题意，这种解法最后获得的是咱们自定义数组的序号，而不是题目要求的序号，晕倒。。。后来发现一个更严重的问题。。他没有说过不能有负数！！！！也就不须要判断数组里的值是否大于和。。。

而后从新构思一下，先来个基本的解法

方法一：暴力循环

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i=0;i<nums.length;i++){
           for(int k=i+1;k<nums.length;k++){
                if(nums[i]+nums[k]==target){
                    return new int[]{i,k};
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}复制代码

至于结果嘛，最简单的天然也高效不到哪里。

效率

分析
这个方法的原理很简单，就是将每个值与其余的值循环遍历，看是否有符合条件的状况发生。稍微要注意的是 for(int k=i+1;k<nums.length;k++) 这里k=i+1是为了不前面循环过的状况再次循环一遍。
时间复杂度 ： O(n^2) 。n个元素都要循环遍历数组内其他的元素，因此是n^2。
空间复杂度 ： O(1) .

方法二：两次循环的 hash table

public class Solution {
   public int[] twoSum(int[] numbers, int target) {
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    for (int i = 0; i < numbers.length; i++) {
        map.put(numbers[i],i);
    }
   for (int i = 0; i < numbers.length; i++) {
       int requestNum = target - numbers[i];
        if (map.containsKey(requestNum)&&map.get(requestNum)!=i) {
            return new int[]{i,map.get(requestNum)};
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}
}复制代码

能够看到效率有了很大的提高。

效率

分析
这个方法的原理其实就是使用hash table 来将时间成原本替换空间成本，将一次复杂度为O(n)的循环变为接近O(1)的查找，为何是接近呢，由于若是hash table发生大量的碰撞，就会致使复杂度向O(n)靠近。咱们将数组里每个元素的值做为key存入hash table，而将其序列号做为对应的value存入hash table，而后遍历数组查找是否有对应的值在hash table 的key中，有则取出该key对应的value。
时间复杂度 ： O(n)
空间复杂度 ： O(n)

方法三：一次循环的 hash table

public class Solution {
   public int[] twoSum(int[] numbers, int target) {
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    for (int i = 0; i < numbers.length; i++) {
       int requestNum = target - numbers[i];
        if (map.containsKey(requestNum)) {
            return new int[]{map.get(requestNum),i};
        }
        map.put(numbers[i],i);
    }
    throw new IllegalArgumentException("No two sum solution");
}
}复制代码

效率稍微提升了一些。。可是有些不能接受啊。怎么还只是在中间的位置。。。而后试了几回，大概在40%到50%徘徊，前面那些是用什么算的。。。为什么那么快。理论上来讲至少须要循环比对结果一次，也就是须要O(n)的复杂度。

效率

分析
这个方法的原理其实就是方法二的一个改善，由于咱们不须要将所有的数组都放入hash table ，咱们最终的目的是为了获得两个相加等于目标数的值的序号便可，因此咱们在将数组里的值放入hash table 的时候就进行比对，一旦获得所须要的值当即结束循环。
时间复杂度 ： O(n)
空间复杂度 ： O(n)

若是你有更好的办法或者对我这里的描述有其余见解，请联系我。谢谢

更多
github.com/LeonChen102…