Leetcode题库1，两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

解题思路：

1.暴力解法，两个for循环遍历所有的求解。

//暴力的方法，但是O(n2),不是很好的算法
class Solution {
    public int[] twoSum(int[] nums, int target) {
        int a[]=new int[2];
        for (int i=0;i< nums.length;i++){
            for (int j=i+1;j< nums.length;j++){
                if (nums[i]+nums[j]==target){
                    a[0]=i;
                    a[1]=j;
                    return a;
                }
            }
        }
        return a;
    }
}

能提交，但是结果很不乐观。

执行结果：

通过

执行用时：55 ms, 在所有 Java 提交中击败了29.97%的用户

内存消耗：38.8 MB, 在所有 Java 提交中击败了18.36%的用户

通过测试用例：55 / 55

2.于是我思考能不能设计出更高效的算法：

减少遍历的次数：

执行结果：

通过

执行用时：54 ms, 在所有 Java 提交中击败了31.21%的用户

内存消耗：38.7 MB, 在所有 Java 提交中击败了36.71%的用户

import java.util.Arrays;
public class Solution {
       public int[] twoSum(int[] nums, int target) {
        if (target<0){
            for(int i=0;i<nums.length;i++)
                nums[i]=-nums[i];
            target=-target;
        }
        int a[]=new int[2];
        a[0]=-1;
        int flat=0,flat1=0,flat2=0;
        int[] v1=new int[nums.length+1];
        for (int i=0;i<nums.length;i++){
            v1[i]=nums[i];
        }
        v1[nums.length]=target;
        Arrays.sort(v1);
        for (int i=0;i<v1.length;i++)
            if(v1[i]==target)
                flat=i;
        for(int i=0;i<flat;i++){
            for(int j=i+1;j<v1.length;j++){
                if(j==flat)
                    continue;
                if(v1[i]+v1[j]==target){
                    flat1=v1[i];
                    flat2=v1[j];
                    break;
                }
            }
        }

        for (int i=0;i<nums.length;i++){
            if(nums[i]==flat1 && a[0]==-1)
                a[0]=i;
            if(nums[i]==flat2)
                a[1]=i;
        }
        if(a[0]>a[1]){
            int t=a[0];
            a[0]=a[1];
            a[1]=t;
        }
        return a;
    }
}

3.这题的复杂程度在要不断的遍历寻找是不是拥有新的值，并且题目说过正确解是唯一的，所以就用哈希表！使得代码性能更好！代码量也大大减少！

    public int[] twoSum(int[] nums, int target){
        int a[]=new int[2];
        a[0]=-1;
        int flat1=0;int flat2=0;
        HashMap<Integer, Integer>hashMap = new HashMap<Integer, Integer>();
        for (int i=0;i<nums.length;i++)
            hashMap.put(nums[i],target-nums[i]);
        Iterator iterator=hashMap.keySet().iterator();
        for(int i=0;i<nums.length;i++){
            int key=hashMap.get(nums[i]);
            if(hashMap.get(key)!=null) {
                flat1=key;
                flat2=hashMap.get(key);
            }
            }