LeetCode - 001 两数字和

原创已于 2024-03-03 17:57:43 修改 · 227 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #哈希算法 #散列表

于 2018-07-31 08:28:20 首次发布

Leetcode/剑指offer/算法/数据结构专栏收录该内容

84 篇文章

订阅专栏

本文深入探讨了经典的两数之和算法问题，介绍了三种解决方案：暴力解法、两次遍历的哈希表方法及一次遍历的优化哈希表方法。详细解释了如何利用哈希表在O(n)时间内找到数组中和为目标值的两个数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:


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

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

方法一：两次遍历
比较高效的索引方案是哈希表：哈希表通过以空间换取速度的方式，将查找时间从 O(n) 降低到 O(1) 。哈希表它支持以近似恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 O(n) 。但只要仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1) 。我们可以用一个简单使用两次迭代来解决这道题目：在第一次迭代中，我们将每个元素的值和它的索引添加到表中；然后在第二次迭代中，我们将检查每个元素所对应的目标元素 (target−nums[i]) 是否存在于表中。注意，该目标元素不能是 nums[i] 本身！

答案：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> twoSum;
        map<int, int> tmp_map;
        for(int i = 0 ;i < nums.size();i++)
        {
            tmp_map[nums[i]] = i;	//key为nums的值，value为nums值的索引
        }
        for(int i = 0 ;i < nums.size();i++)
        {
            int another = target - nums[i];
            if(tmp_map.find(another)!=tmp_map.end() && tmp_map[another]!=i)
            {
                twoSum.push_back(i);
                twoSum.push_back(tmp_map[another]);
                break;       
            }
        }
        return twoSum;
        
    }
};

一样的思路，代码可以改写为

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        std::map<int, int> mp;
        if(nums.empty()){
            return res;
        }
        int n = nums.size();
        for(int i = 0; i < n; i++) {
            if(mp.count(target - nums[i]) > 0) {
                res.emplace_back(i);
                res.emplace_back(mp[target - nums[i]]);
                break;
            }
            mp[nums[i]] = i;
        }
        return res;
    }
};

时间复杂度：O(n)，我们把包含有 n 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1) ，所以时间复杂度为 O(n) 。
空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。

方法二：一次遍历
其实优化策略就是把两次遍历合为一次：在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> twoSum;
        map<int, int> tmp_map; //key为nums的值，value为nums值的索引
        for(int i = 0 ;i < nums.size();i++)
        {
            int another = target - nums[i];
            if(tmp_map.find(another)!=tmp_map.end())
            {
                twoSum.push_back(tmp_map[another]);
                twoSum.push_back(i);
            }
            tmp_map[nums[i]] = i;
        }
        return twoSum;
    }
};

方法三：暴力解法
这个直接遍历所有元素就好，和上面的方法二接近，代码简单易懂，无需赘述，直接看代码就好。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        if(nums.empty()){
            return res;
        }
        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) {
                    res.emplace_back(i);
                    res.emplace_back(j);
                    break;
                }
            }
        }
        return res;
    }
};

最简洁版本代码

class Solution {
public:
    unordered_map<int,int> mp1;
    vector<int> twoSum(vector<int>& nums, int target) {
        for( int i=0;i<nums.size();i++ ){
            if( mp1.count(target-nums[i]) ) return vector<int>{i,mp1[target-nums[i]]};
            else mp1[nums[i]]=i;
        }
        return vector<int>();
    }
};