代码随想录算法训练营第六天|力扣242. 有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

最新推荐文章于 2024-06-12 10:00:23 发布

凌锋lin6

最新推荐文章于 2024-06-12 10:00:23 发布

阅读量3.5k

点赞数 1

分类专栏：代码随想录刷题ing 文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/weixin_43434369/article/details/129117627

版权

代码随想录刷题ing 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

代码随想录算法训练营第六天|力扣242. 有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

什么时候想到用哈希法，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

242. 有效的字母异位词

题目链接：有效的字母异位词

题目描述：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例1：

输入: s = "anagram", t = "nagaram"
输出: true

示例2：

输入: s = "rat", t = "car"
输出: false

提示:

1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母

思路：

数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。
需要定义一个多大的数组呢，定一个数组叫做record，大小为26 就可以了，初始化为0，因为字符a到字符z的ASCII也是26个连续的数值。
定义一个数组叫做record用来上记录字符串s里字符出现的次数。
需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。
再遍历字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。
那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。
那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。
最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。
复杂度分析

时间复杂度为O(n)，空间上因为定义是的一个常量大小的辅助数组，所以空间复杂度为O(1)。

易错点：

定义一个数组时要注意:

int record[26] = {0}; //花括号

代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[s[i] - 'a']++;
        }
        for (int i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

当我们需要快速判断一个元素是否出现在集合中时，就要考虑使用哈希法。它的优势是速度快，但当哈希值比较大时就不适合了。

常用的三种哈希表有数组、set和map，当哈希表比较小并且范围确定的时候，用数组；当哈希表范围比较大而且不确定的时候，用set；当有key-value的映射关系的时候，用map。

349.两个数组的交集

题目链接：两个数组的交集

题目描述：

给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。
示例1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例2：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

思路：

这道题目，主要要学会使用一种哈希数据结构：unordered_set，这个数据结构可以解决很多类似的问题。
注意题目特意说明：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的，同时可以不考虑输出结果的顺序。

若题目中限制了数组的长度，则用数组和set的方法均可，数组的方法速度更快；
若题目中哈希值比较少、比较分散、跨度非常大，使用数组会造成极大的空间浪费，用set更好。

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。
思路如下所示：
在这里插入图片描述

代码如下：

（1）用set做哈希表

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());//读取nums1里出现过的所有元素
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());//将set再转化为vector数组
    }
};

复杂度分析：

时间复杂度和空间复杂度都是O(N)。

将nums1中的元素存入set数据结构中，就是O(N)的时间复杂度，然后遍历num2中的元素一个个比较，又是O(N)的时间复杂度，最后把result转换成list，也是O(N)的时间复杂度，所以总体来说time
complexity = O(N)；空间上创建了两个set和一个list，长度都是O(N)数量级的，所以space complexity =
O(N)。

（2）用数组做哈希表
本题后面力扣改了题目描述和后台测试数据，增添了数值范围：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000
所以就可以使用数组来做哈希表了，因为数组都是 1000以内的。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; // 默认数值为0
        for (int num : nums1) { // nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for (int num : nums2) { // nums2中出现话，result记录
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

复杂度分析：

时间复杂度和空间复杂度均为O(N)；在时间上，因为需要分别遍历nums1和nums2，均为O(N)，所以整体复杂度为O(N)；

在空间上，因为需要新建一个result的set，为O(N)，因为nums1和2
最大的长度限制在1000以内，所以新建的数组不能认为是常数级别了（not
sure），新建的数组，空间复杂度也为O(N)，整体空间复杂度为O(N)。

易错点：

nums2实际是一个查询的作用。
注意新出现的set关于for循环的写法：

for (int num : nums2) { }

用unordered_set来读取数组元素的写法：

unordered_set<int> nums_set(nums1.begin(), nums1.end());//读取nums1里出现过的所有元素

set是类数组结构，所以最后要将其转换成真实的数组

理解一下

疑问：遇到哈希问题我直接都用set不就得了，用什么数组啊！
直接使用set不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。不要小瞧这个耗时，在数据量大的情况，差距是很明显的。

*202. 快乐数

题目链接：快乐数

题目描述：

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。
如果这个过程结果为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 true ；不是，则返回 false 。

示例1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例2：

输入：n = 2
输出：false

提示：

1 <= n <= 2^31 - 1

思路：

这道题目看上去貌似一道数学问题，其实并不是！
题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！
当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。
所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false，否则一直找到sum为1为止。

判断sum是否重复出现就可以使用unordered_set。

还有一个难点就是求和的过程，如果对取数值各个位上的单数操作不熟悉的话，做这道题也会比较艰难。

代码如下：

class Solution {
public:
    // 取数值各个位上的单数之和
    int getSum(int n) {
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while(1) {
            int sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

复杂度分析：

时间复杂度：O(243 * 3 + log n + log log n + log log log n). = O(logn)。

查找给定数字的下一个值的成本为 O(log n)，因为我们正在处理数字中的每位数字，而数字中的位数由log n 给定；
要计算出总的时间复杂度，我们需要仔细考虑循环中有多少个数字，它们有多大；我们在上面确定，一旦一个数字低于243，它就不可能回到 243
以上。因此，我们就可以用 243 以下最长循环的长度来代替 243，不过，因为常数无论如何都无关紧要，所以我们不会担心它；对于高于 243
的 n，我们需要考虑循环中每个数高于 243 的成本。通过数学运算，我们可以证明在最坏的情况下，这些成本将是 O(log n) +
O(log log n) + O( log log log n)…幸运的是，O(log
n)是占主导地位的部分，而其他部分相比之下都很小（总的来说，它们的总和小于logn），所以我们可以忽略它们。空间复杂度：O(logn)。

与空间复杂度密切相关的是衡量我们放入哈希集合中的数字以及它们有多大的指标。对于足够大的n，大部分空间将由 n
本身占用。放入哈希集合中的下一个元素的大小应该是logn量级的。（？ not sure）

另外提一句，我们可以很容易地把空间复杂度优化到 O(243 * 3) = O(1)，方法是只保存集合中小于 243
的数字，因为对于较高的数字，无论如何都不可能返回到它们。

1.两数之和

题目链接：两数之和
给定一个整数数组 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 <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

思路：

主要思考四个问题：

为什么要用哈希法。
当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。
本题呢需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是是否出现在这个集合。
为什么要用map。
我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。
再来看一下使用数组和set来做哈希法的局限。

数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。
此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下标。
C++中map，有三种类型：

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。
同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。
这道题目中并不需要key有序，选择std::unordered_map 效率更高！

map用来做什么
map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）
map中key和value分别表示什么
这道题我们需要给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。
那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。
所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。
在遍历数组的时候，只需要向map去查询是否有和目前遍历元素比配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

过程如下：
在这里插入图片描述

代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;//格式注意下
        for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            //这里it被自动推断为map<int, int>::iterator类型
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

复杂度分析：

时间复杂度：O(N)

因为nums中的每个值都要遍历一遍做相应的处理，所以为O(N)；

空间复杂度：O(N)

因为要创建一个字典数据结构，然后储存遍历过数据的信息，空间复杂度为O(N)

关于pair的说明：如果一个函数有两个返回值的话，如果是相同类型，就可以用数组返回，如果是不同类型，两个属性的话，就可以用pair 进行操作，有多个属性的时候，可以使用tuple。
生成方法两种：

pair<int ,int >p (5,6);
pair<int ,int > p1= make_pair(5,6);

pair<string,double> p2 ("aa",5.0);
pair <string ,double> p3 = make_pair("aa",5.0);

总结：

暴力解法是我们都能想到的，但是我们要有这样的一种本能：

当发现自己的代码里有两层循环时，先反思一下，能不能用空间换时间，把它优化成一层循环。

拿我们这道题来说，其实二层遍历是完全不必要的。
大家记住一个结论：几乎所有的求和问题，都可以转化为求差问题。 这道题就是一个典型的例子，通过把求和问题转化为求差问题，事情会变得更加简单。
我们可以在遍历数组的过程中，增加一个 Map 来记录已经遍历过的数字及其对应的索引值。然后每遍历到一个新数字的时候，都回到 Map 里去查询 target 与该数的差值是否已经在前面的数字中出现过了。若出现过，那么答案已然显现，我们就不必再往下走了。

参考链接：
https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html
https://programmercarl.com/0242.%E6%9C%89%E6%95%88%E7%9A%84%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D.html
https://programmercarl.com/0349.%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86.html
https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html
https://programmercarl.com/0001.%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C.html
https://blog.csdn.net/weixin_47284299/article/details/127049661?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22127049661%22%2C%22source%22%3A%22weixin_47284299%22%7D

凌锋lin6

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营第六天|力扣242. 有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

代码随想录算法训练营第六天|力扣242. 有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和
复制链接

扫一扫