LeetCode:两数之和

题目描述：

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

解题思路：

1.穷举暴力破解

很容易想到的是暴力破解，直接两个for循环，外层循环控制被加数，内层循环控制加数，这样解题的时间复杂度在$O(N^2)$。这是很容易想到的一种方法，那么进阶的思路是考虑一种比暴力破解时间复杂度更低的解题算法。

class Solution {
public:
    	vector<int> twoSum(vector<int>& nums, int target) {
    	int flag = 0;
        for(int i=0;i<nums.size();i++)
        {
            int sum1 = nums[i];
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[j]==target-sum1)
                {
                    res[0] = i;
                    res[1] = j;
                    flag = 1;
                    break;
                }
            }
            if(flag==1) break;
        }
        return res;
    }
};

2.哈希表

使用哈希表。都知道，哈希表的查表时间复杂度在$O(1)$，那么我们可不可以把原始数据进行哈希映射之后，再来进行对数据的查询呢？这样处理后的时间复杂度控制在$O(1)+O(N)$。很明显时间复杂度降低了，那么直接开干。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> hashmap;
       vector<int> res(2,0);
       for(int i=0;i<nums.size();i++)
       {
            hashmap.insert(map<int,int>::value_type(nums[i],i));//map的存储方式是key-value，这里将num[i]作为key，i为作value
       }
       for(int i=0;i<nums.size();i++)
       {
            if(hashmap.count(target-nums[i])>0&&(hashmap[target-nums[i]]!=i))
            //在map中寻找tartget-sums[i]是否存在，
            //同时如果存在，那是否与当前的nums[i]相等，也就是另一个加字不能是当前的nums[i]
            {
                res[0]=i;
                res[1]=hashmap[target-nums[i]];
                break;//找到了之后就直接break
            }
       }
       return res;
    }
};

最终结果：

可以看到，暴力破解的执行时间是hash法的大概50倍，两个算法的空间复杂度上也比较接近，顾，对于数组上的一些算法处理，可以使用、hash映射来进行处理，执行时间会更快。