【每日力扣9】两数之和

一、题目

给定一个整数数组 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]

提示：

• 2 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9
• -10^9 <= target <= 10^9

只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n²) 的算法吗？

二、思路

（1）暴力法

最简单的方法为直接使用两个循环，两轮搜索查找i,j使得nums[i]+nums[j] == target。但是时间复杂度为O(N²)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        for(int i = 0 ; i< n; i++)
        {
            for(int j = i + 1; j < n ; j++)
            {
                if(nums[i] + nums[j] == target)
                {    
                    vector<int> ans(2);
                    ans[0] = i;
                    ans[1] = j;
                    return ans;
                }
            }
        }
        vector<int> ans(1,0);
        return ans;
    }
};

 

（2）哈希法

利用哈希表支持在常数时间内插入、删除和查找元素的特性，我们引入一个STL中的哈希表（就懒得自己构造了hhhh）unodered_set，将数组nums[]中的元素放进去。对于每一个nums[i]，用unodered_set的find()方法查找哈希表中是否有元素其值为target - nums[i]（只需要O(1)时间~），如果发现有，那么就找出在数组nums[]中该元素的下标j（用一层for循环遍历，O(N)）。最后返回由两下标构成的数组{i,j}即可。

时间复杂度为O（N），空间复杂度也为O（N）。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        unordered_set<int> hashTale;//创建一个哈希set容器
        for(int i=0; i< n; i++)//遍历数组，对于每一个nums[i]
        {
            if(hashTale.find(target - nums[i])!=hashTale.end())//先用哈希set的查找find()方法判断哈希表里是否存在元素其值为target-nums[i]
                {//如果存在，
                    for(int j = 0; j < n; j++)//则再次遍历数组，找出那个j值
                        if(nums[j] == target - nums[i])//使得nums[j] = target - nums[i]
                            {
                                vector<int> ans(2);//将i，j装入向量中，返回答案
                                ans[0] = j;
                                ans[1] = i;
                                return ans;
                            }
                }
            hashTale.insert(nums[i]);//若哈希表中尚未找到target-nums[i]，则先把nums[i]存入
        }
        vector<int> ans(1,0);//若查找失败，返回{0}
        return ans;
    }
};

三、官方解法

方法一：暴力枚举

思路及算法

最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。

当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。

 

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

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：O(N^2)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
• 空间复杂度：O(1)。

方法二：哈希表（哈希map法）

思路及算法

注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。

使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。

这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;
        for (int i = 0; i < nums.size(); ++i) {
            auto it = hashtable.find(target - nums[i]);
            if (it != hashtable.end()) {
                return {it->second, i};
            }
            hashtable[nums[i]] = i;
        }
        return {};
    }
};
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
• 空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。

四、学习心得

1.unordered_map的使用

同为哈希表法，官解使用的是map，而笔者是set。在本题中使用map比set更为高明。map相当于用pair<keyType, valueType>实例化的set，可以存储二元数据项。在本题可以存储数组元素值nums[i]——作为数据项的键，和数组元素下标i。二者以pair<int, int>形式同时存储在一起，这样就不需要额外用一次for循环遍历整个数组来找target-num[i]的下标j啦——因为target-num[i]已经和它的下标一起存进哈希表里了，只需要用find()方法找到后直接用迭代器itr->second返回即可！

2.vector<type>的返回

可以直接用return{i，j}返回，不需要多余几行冗杂的代码来声明一个vector<int>还要在赋值再返回。