哈希表理论基础
目的：快速判断一个元素是否出现集合里
常见的三种哈希结构
数组、set （集合）、map(映射)
（偷懒直接截图了）
242.有效的字母异位词
题目链接
状态：两遍过
错误原因：为考虑两字符串长度不同可直接返回false
思路：之前在《904. 水果成篮》中学到的unordered_map可直接用
class Solution {
public:
bool isAnagram(string s, string t) {
int m = s.size(), n = t.size();
if (m != n) return false;//第一次未考虑到
unordered_map<char, int> ans;
for (int i = 0; i < m; i++) ans[s[i]]++;
for (int j = 0; j < n; j++)
if (--ans[t[j]] < 0)
return false;
return true;
}
};
有更高级写法可以学习借鉴
for (char i : s) // 遍历字符串 s，统计其中每个字符出现的次数，并将其存储在 map1 中
ans[i]++;
for (char i : t) // 遍历字符串 t，对于其中的每个字符，减少其在 map1 中的计数器
ans[i]--;
for (auto it : ans) { // 遍历 map1 中的所有键值对
if (it.second != 0) { // 如果有任何一个键值对的值不为零，则表示两个字符串不互为字谜，返回 false
return false;
答案还有一种暴力排序做的
class Solution {
public:
bool isAnagram(string s, string t) { // 定义 isAnagram 方法，接受两个字符串参数
if(s.length()!=t.length()) // 如果两个字符串的长度不同，直接返回 false，它们不可能互为字谜
return false;
sort(s.begin(),s.end()); // 对字符串 s 进行排序
sort(t.begin(),t.end()); // 对字符串 t 进行排序
return s==t; // 返回字符串 s 和 t 是否完全相同
}
};
相关题目
383. 赎金信
题目链接
思路一样，甚至无需比较
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
unordered_map<char, int> ans;
for (char i :magazine) ans[i]++;
for (char j :ransomNote)
if (--ans[j] < 0)
return false;
return true;
}
};
49. 字母异位词分组
题目链接
状态：难，没做出来
思路：很复杂，
答案思路参考：
两个字符串互为字母异位词，当且仅当两个字符串包含的字母相同。同一组字母异位词中的字符串具备相同点，可以使用相同点作为一组字母异位词的标志，使用哈希表存储每一组字母异位词，哈希表的键为一组字母异位词的标志，哈希表的值为一组字母异位词列表。
遍历每个字符串，对于每个字符串，得到该字符串所在的一组字母异位词的标志，将当前字符串加入该组字母异位词的列表中。遍历全部字符串之后，哈希表中的每个键值对即为一组字母异位词。
官方题解
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string>& strs) {
unordered_map<string, vector<string>> mp;
for (string& str: strs) {
//string& str 的使用是为了提高效率，避免在每次迭代中复制字符串，从而减少内存和时间开销。
string key = str;
sort(key.begin(), key.end());
mp[key].emplace_back(str);
//push_back：需要先构造一个临时对象，然后将其拷贝或移动到容器中。对于非平凡构造（例如自定义类的对象），这意味着需要额外的构造和析构开销。
//emplace_back：直接在容器末尾构造对象，避免了临时对象的创建和销毁，通常比 push_back 更高效。
}
vector<vector<string>> ans;
for (auto it = mp.begin(); it != mp.end(); ++it) {
ans.emplace_back(it->second);
//每个元素（键值对）包含两个部分：键（first）和值（second）。
//it->first：返回当前迭代器 it 指向元素的键.
//it->second：返回当前迭代器 it 指向元素的值。
}
return ans;
}
};
思路二：使用哈希表
思路：使用长度为 26 的数组记录每个字母出现的次数，这也是我最开始想要使用的思路，奈何水平不够，没整理出来。
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string> &strs) {
unordered_map<string, vector<string>> m;
for (auto &s : strs) {
string sorted_s = s;
ranges::sort(sorted_s);
m[sorted_s].push_back(s); // sorted_s 相同的字符串分到同一组
}
vector<vector<string>> ans;
ans.reserve(m.size()); // 预分配空间
for (auto &[_, value] : m) {
ans.push_back(value);
}
return ans;
}
};
438. 找到字符串中所有字母异位词
题目链接
状态：超时
思路：暴力直接将p字符串排序后放到map中，在从s字符串中依次取p长度的子字符串，排序后和map中的比较，若相同返回下标索引，反之继续。
初始超时代码：
class Solution {
public:
vector<int> findAnagrams(string s, string p) {
int m = s.size(), n = p.size();
unordered_map<string, int> mp;
vector<int> res;
string sub;
sort(p.begin(),p.end());
mp[p]++;
for (int j = 0; j < m - n + 1; j++) {
sub = s.substr(j, n);
sort(sub.begin(),sub.end());
if (mp[sub] != 0)
res.push_back(j);
}
return res;
}
};
修改版：使用滑动窗口
class Solution {
public:
vector<int> findAnagrams(string s, string p) {
int m = s.size(), n = p.size();
if (m < n)
return {};
unordered_map<char, int> mp_s, mp_p;
vector<int> res;
for (char i : p)
mp_p[i]++;
for (int j = 0; j < n; j++) {
mp_s[s[j]]++;
}
// 滑动窗口
if (mp_s == mp_p)
res.push_back(0);
for (int i = 0, j = n; j < m; i++, j++) {
mp_s[s[j]]++; // 增加滑动窗口右边界字符的频率
if (--mp_s[s[i]] == 0) // 减少滑动窗口左边界字符的频率
mp_s.erase(s[i]); // 如果频率为零，删除该字符
if (mp_s == mp_p) res.push_back(i + 1);
}
return res;
}
};
忽然发现 unordered_map 好像没什么用，下附一个关于滑动窗口的链接，学完后无敌
滑动窗口
349. 两个数组的交集
题目链接
状态：错一次
错误原因：未考虑返回数组不重复问题
思路：用哈希表先记录一个数组的元素，个数统一为一，再遍历第二个数组，若哈希表里已有则将个数置0，并加入到返回向量中。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int,int> ans;
vector<int> res;
for(int i:nums1) ans[i]=1;
for(int j:nums2)
if(ans[j]==1){
ans[j]=0;
res.push_back(j);
}
return res;
}
};
看了标准答案，和他思路一样不过写法我的好像更好一点
下面的答案值得学习
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());
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());
}
};
//当使用 end() 函数时，它并不指向任何有效的元素，而是表示迭代器已经遍历完容器内的所有元素。
//在 unordered_set 的上下文中，由于它是无序的，end() 并不指向一个特定的元素，它仅仅是一个用来表示遍历结束的迭代器。
//在代码中，nums_set.find(num) != nums_set.end() 这行检查 find 函数返回的迭代器是否不等于 end()。
//如果 find 函数找到了元素 num，它将返回指向该元素的迭代器；如果没有找到，它将返回 end()。这个检查用于确定元素是否存在于 nums_set 中。
在这个问题中，使用 unordered_set 而不是 unordered_map 主要基于以下原因：
-
需求: 问题要求找出两个数组的交集，即找到在两个数组中都存在的元素。这不需要存储任何额外的信息，只需要知道某个元素是否存在。
-
性能: unordered_set 提供平均常数时间复杂度的查找性能，这使得它非常适合快速检查元素是否存在。
-
简洁性: 使用 unordered_set 可以避免不必要的复杂性。unordered_map 存储键值对，而在这个场景中，我们不需要存储任何值，只需要知道元素是否存在。
-
内存使用: unordered_set 只存储元素本身，而 unordered_map 需要额外的空间来存储与每个键关联的值（在这个场景中，值是不必要的）。
-
实现简单性: 使用 unordered_set 可以简化代码实现，因为不需要处理键值对，只需要处理单个元素。
-
自动去重: unordered_set 会自动去除重复元素，这正是寻找两个数组交集所需要的特性。
-
直接使用: unordered_set 可以直接使用 insert 或 emplace 方法添加元素，并利用 count 或 find 方法检查元素是否存在。
-
转换方便: 最终结果需要转换为 vector，而 unordered_set 可以直接转换为 vector，因为集合中的元素已经是排序好的。
使用 unordered_map 在这个场景下可能会引入不必要的复杂性和性能开销，因为 unordered_map 需要额外的内存来存储值，并且在每次查找时都需要处理键值对，这在只需要检查元素存在性的情况下是不必要的。
202. 快乐数
题目链接
状态：错两次
错误原因：1. 未考虑无限循环。2. set.find(num) != set.end()理解出错，应为重复出现而不是未出现
初始代码：
class Solution {
public:
int func(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) {
n = func(n);
if(n==1) break;
if (set.find(n) != set.end())
return false;
else
set.insert(n);
}
return true;
}
};
改进写法：
bool isHappy(int n) {
unordered_set<int> set;
while (true) {
n = func(n);
if (n == 1) return true; // 如果 n 变为 1，这是一个快乐数
auto result = set.insert(n).second; // 尝试插入 n 并获取插入成功与否的状态
if (!result) return false; // 如果插入失败，说明 n 已经出现过，返回 false
}
}
insert 函数的返回值是一个 pair 类型，其中：
pair::first 是一个迭代器，指向集合中的元素，如果插入成功，它指向新插入的元素；如果元素已存在，则指向已存在的元素。
pair::second 是一个布尔值，表示插入操作是否成功。如果 second 为 true，则表示元素被成功插入；如果为 false，则表示元素已存在，没有执行插入操作。
1. 两数之和
题目链接
状态：只想到了暴力方法
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 {0};
}
};
重点：当需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。本题需要一个集合来存放遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。
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
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 {};
}
};
理解：就遍历一个 n u m s [ i ] nums[i] nums[i]，就在哈希表中找他相对应加和为 t a r g e t target target 的数 t a r g e t − n u m s [ i ] target-nums[i] target−nums[i] ，若有则返回，否则添加进去。
134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
