Leetcode 01两数之和（python和c++）

原创已于 2024-10-20 18:31:34 修改 · 393 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #哈希算法

于 2018-11-15 15:37:53 首次发布

C/C++ 同时被 2 个专栏收录

98 篇文章

订阅专栏

算法题leetcode

63 篇文章

订阅专栏

本文深入探讨了经典的“两数之和”算法问题，提供了两种解决方案：穷举法和哈希法。通过C++与Python代码实现，对比了不同方法的效率与内存消耗，适合初学者理解算法思想。

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

题目：

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

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

示例:

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

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

C++代码实现

（1）穷举法

执行用时：304 ms, 在所有 C++ 提交中击败了27.90%的用户

内存消耗：10 MB, 在所有 C++ 提交中击败了59.76%的用户

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

补充：关于vector大小（size）和容量（capacity）总结

（2）哈希

算法逻辑：使用哈希表存储数组内的所有值和索引对，然后组个遍历，查找另一个值是否在哈希表内即可。

执行用时：8 ms, 在所有 C++ 提交中击败了92.48%的用户

内存消耗：12.1 MB, 在所有 C++ 提交中击败了5.00%的用户

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {   
        // 哈希
        unordered_map<int,int> ha_val_idx;
        for(int i = 0; i < nums.size(); i++)
            ha_val_idx.insert(pair<int,int>(nums[i],i));
        
        for(int i = 0; i < nums.size(); i++)
        {
            int another = target-nums[i];
            // 存在，且不重复，即[1,2,3],target=4,不能是[2,2]
            // [3,3] 6. 返回：[0,1]
            if(ha_val_idx.count(another)>0 && (ha_val_idx[another]!=i))
                return {i, ha_val_idx[another]};
        }
        return {};

    }
};

python实现

执行用时：28 ms, 在所有 Python 提交中击败了56.72%的用户

内存消耗：13.5 MB, 在所有 Python 提交中击败了83.20%的用户

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        # 哈希表
        ha_value_idx = {}
        for i, val in enumerate(nums):
            ha_value_idx[val] = i
        
        for i, val in enumerate(nums):
            # 其中一个值为val，找另一个值target-val，该值即为哈希表的索引。
            j = ha_value_idx.get(target - val)
            if j is not None and i != j:  # 数组中同一个元素在答案里不能重复出现。
                return [i, j]
        return []

(3) 哈希

算法逻辑：一样使用哈希表，不过这里的哈希表用来存储已经访问过的数字及其对应的索引，初始时哈希表为空。这样当我们遍历数组时，可以快速查找当前元素与目标值之间的差值是否已经在哈希表中存在。如果存在，那么我们找到了一对解；如果不存在，则将当前元素加入到哈希表中继续搜索。

执行用时分布：0ms击败100.00%

消耗内存分布：14.07MB击败31.53%

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map<int, int> lookup_table;
        for (int i = 0; i < nums.size(); ++i) {    
            // 另一个值是否在哈希表中
            if (lookup_table.find(target - nums[i]) != lookup_table.end()) {
                return {i, lookup_table[target - nums[i]]};
            }
            // 不在，则加入到哈希表，因为它的配对值可能还在数组中。
            lookup_table[nums[i]] = i;
        }
        return {};
    }
};