给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
    你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
    示例:

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

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

    1、暴力法

    1. class Solution {
    2.     public int[] twoSum(int[] nums, int target) {
    3.         for(int i=0;i<nums.length;i++) {
    4.             for(int j=i+1;j<nums.length;j++) {
    5.                 if(nums[i]+nums[j]==target) {
    6.                     return new int[] {i,j};
    7.                 }
    8.             }
    9.         }
    10.         return new int[] {-1,-1};
    11.     }
    12. }

    这个很简单，不多说，时间复杂度是O(n^2)，空间复杂度是O(1)
    结果：image.png

    2、一次哈希遍历

    1. class Solution {
    2.     public int[] twoSum(int[] nums, int target) {
    3.          HashMap<Integer,Integer> map = new HashMap();
    4.         for (int i = 0; i < nums.length; i++) {
    5.             int num2 = target-nums[i];
    6.             if(map.containsKey(num2)) {
    7.                 nums = new int[]{map.get(num2),i};
    8.                 return nums;
    9.             }
    10.             map.put(nums[i],i);
    11.         }
    12.         return null;
    13.     }
    14. }

    思路：遍历数组往map里面插数据，数组的值作为key，下标作为value，每一次插入之前都嫌判断一下是否存在差的key，如果存在就返回，不存在就继续；

    时间复杂度是O(n),我们只遍历了包含有 nn 个元素的列表一次。在表中进行的每次查找只花费 O(1)O(1) 的时间
    空间复杂度是O(n),所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n个元素

    结果:image.png