来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum

1.两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

这道题看起来比较简单，首先能想到的方式就是双层for循环来解决：

解法一：双层for循环解决

    public int[] twoSum(int[] nums, int target) {
          for(int i=0;i<nums.length;i++){
              for(int j=i+1;j<nums.length;j++){
                   if ( nums[i]+nums[j] == target) {
                      return new int[] { i, j };
                    }
              }
           }
//没有找到对应的两个值  抛异常或者你可以返回new int[]{-1,-1}
      throw new IllegalArgumentException("No two sum solution");
    }

上述解法当然米有问题，但是作为coder我们考虑问题要全面，不仅仅是给出一个简单的解决方案。首先我们考虑以下，这个算法的时间复杂度为O(n2)

复杂度分析：

时间复杂度：O(n^2)， 对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n)的时间。因此时间复杂度为 O(n^2)

空间复杂度：O(1)。

那有没有另外一种方案呢？我们牺牲一点空间换取一点时间OK吗？答案是肯定的！

方法二：借助hash表优化查找速度

    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement) && map.get(complement) != i) {
                return new int[] { i, map.get(complement) };
            }
         }
//没有找到对应的两个值  抛异常或者你可以返回new int[]{-1,-1}
        throw new IllegalArgumentException("No two sum solution");
    }

上述方法还可以稍微改进以下：

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[] { map.get(complement), i };
        }
        map.put(nums[i], i);
    }
//没有找到对应的两个值  抛异常或者你可以返回new int[]{-1,-1}
    throw new IllegalArgumentException("No two sum solution");
}