1. Two Sum [SIMPLE]

题目：给定一个整型数组，返回数组中两数相加和等于target的下标。假设每次输入只有一个结果，你不会两次都用到同一个元素。

1、第一次解法：

    通过创建一个和输入数组大小一样的数组，用target-原数组元素nums[i]并依次赋值给help[i]，建立一个全新的数组help，只需要通过比较当前元素help[i]与原数组nums[i+1]后面的元素是否相等，即可判断nums[i]+nums[j]是否能等于target，相等则返回两元素的下标。

    时间复杂度O(i*j),空间复杂度O(N)

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

2、第二次解法：

    目的：减少空间复杂度。

    发现原来的解法中新建数组是没有必要的，因为每次都只是需要用到一个（target-nums当前元素值）的变量，所以用一个int类型变量代替。

    时间复杂度O(i*j)，空间复杂度O(1)

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

3、第三次解法：使用Map

时间复杂度O(N)，空间复杂度O(1)。避免使用嵌套for循环

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