leetcode练习——Day1——P1 两数之和

原创已于 2025-08-24 23:00:40 修改 · 371 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

于 2025-08-24 19:44:19 首次发布

2025.08.24

前言：上学期被csp考试一直在折磨，也从来没有系统性地刷过题，代码能力非常弱，一个暑假过去更是连基本的STL都有点忘了，开一个帖子来督促自己每天练习。首先，从leetcode简单题开始。

P1：两数之和

题目：

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

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

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

解题思路：

一、暴力，时间复杂度为O（ $^{N^{2}}$ ）

这是我首先想到的算法。

觉得很简单，一想就想到了，但是实际开始写就错误百出。

注意点：

1、vector用法： size()//返回返回容器中元素个数
                                begin()//返回头部迭代器
                                end()//返回尾部+1迭代器
                                rbegin()//返回逆首部迭代器
                                rend()//返回逆尾部-1迭代器
                                front()//返回首个元素
                                back()//返回尾部元素
                                push_back()//在末尾添加一个元素
                                emplace_back()//和push_back()是一样的作用
                                pop_back()//弹出最后一个元素
                                empty()//判断是否为空
                                insert()//在指定位置插入元素
                                erase()//在指定位置删除元素
                                clear()//清空
————————————————
版权声明：本文为优快云博主「旧林墨烟」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/weixin_52115456/article/details/126024253

2、j是从i+1继续开始遍历的，不是从j=i开始遍历的

3、不是void函数，最后需要补一个return { }

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

二、利用哈希表，时间复杂度为O（N）

方法一时间复杂度高在于其会不断遍历已经遍历过的元素，也就是说在遍历到X时，会在遍历的去找target-X是否存在，利用哈希表可以存储可能存在的target-X。

也就是说创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，有的话直接返回答案即可，如果没有的话将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。

这里我的疑惑在于官方解析的一句话：“即可保证不会让 x 和自己匹配”。

当处理 x 时，哈希表中只包含 x 之前的元素（已经遍历过的元素），而不包含 x 本身。因此，即使数组中存在与 x 相等且满足 x + x = target 的元素，也只会匹配到 x 之前出现的那个相同元素，而不会匹配到 x 自己。

e.g.：

如果数组是 [3, 3]，目标值是 6

处理第一个 3 时，哈希表为空，查找不到 3（6-3=3），然后将第一个 3 存入哈希表

处理第二个 3 时，先在哈希表中查找 3（6-3=3），此时能找到第一个 3 的索引，直接返回结果

这样就正确匹配了两个不同位置的 3，而不会出现自己和自己匹配的情况

也就是说这句话解释的是操作顺序。

附上代码：

    vector<int> twoSum(vector<int>& nums, int target) {
        int len = nums.size();
        unordered_map<int,int> hashtable;
        for(int i=0;i<len;i++){
            auto it=hashtable.find(target-nums[i]);
            if(it!=hashtable.end()){
                return {it->second,i};
            }
            hashtable[nums[i]]=i;
        }
        return {}; 
    }