给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

代码如下，类似冒泡排序的写法，i从0到num.length-1，j从i+1到nums.length：

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

但是上面这种写法存在几个问题，首先没有异常处理，然后效率也不行，下面的这个算法要好很多：

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

异常处理就不细说了，从时间复杂度上来说，算法1是T(n^2)，空间复杂度O(1)；算法2是T(n)，空间复杂度O(n)；
提升的关键，就在于使用了一个map，用array元素的值作为key，array的下表作为value，利用哈利表的快速查找优势，用空间换取了时间。

用空间换时间，以前算法课经常到，不理解，但是我们后来常用的很多手段，比如memcached、redis等缓存，都属于是空间换取时间。

根据leetcode的测试，算法1平均需要31ms，算法2仅需要8ms，一个普通的加减法，时间就缩短到原来的1/4，真的是很恐怖的提升，算法的力量。

需要注意的是，算法2也不是绝对优势，因为空间复杂度相对提升，这个例子里面，我们不太能感受到空间复杂度提升带来的副作用，但是如果我们要计算的数据很大，比如大到100GB，而你可支配的内存只有64GB，那算法2就不行了。那算法1呢，可能内存是不需要太多，但是需要1个月来计算，那也不行。最好的办法可能就是“折中”，找到一个最适合自己的那个“度”，不浪费空间，又节省时间。

突然想到一句话叫“万法皆有度”，这个万法应该也包括算法吧，哈哈。