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

    你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

    示例:

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

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

    解法：
    （1）O(n^2)算法

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

    （2）O(n)算法 Java版本

    1. import java.util.HashMap;
    2. import java.util.Map;
    4. public class TwoSum {
    6.     public int[] twoSum(int[] nums, int target) {
    7.         Map<Integer, Integer> map = new HashMap<>();
    8.         for (int i = 0; i < nums.length; i++) {
    9.             int value = target - nums[i];
    10.             if (map.containsKey(value)) {
    11.                 return new int[] {map.get(value), i};
    12.             }
    13.             map.put(nums[i], i);
    14.         }
    15.         return null;
    16.     }
    17. }


    O(n)算法Python版本

    1. from typing import List
    4. class Solution:
    5.     def twoSum(self, nums: List[int], target: int) -> List[int]:
    6.         dict = {}
    7.         for i, n in enumerate(nums):
    8.             if target - n in dict:
    9.                 return [dict[target - n], i]
    10.             dict[n] = i