算法小白训练营日记，笔记为自用，若有错误感谢指出
--今日任务--：哈希表理论基础， 242.有效的字母异位词 ，349. 两个数组的交集 ，202. 快乐数，1. 两数之和
242.有效的字母异位词
题目链接：242. 有效的字母异位词 - 力扣（LeetCode）
解题思路：数组实现哈希表，将s中每个字母出现次数记录在数组的对应位置中，再将数组中对应位置减去t中字母出现次数，最后遍历数组，若存在不为0的情况，则不是有效字母异位词。
定义字母对应位置的方法：无需知道每个字母的ASCII码，用s[i]-'a'即对应位置，若s[i]为a，即对应hash[0]。
具体代码如下：
class Solution {
public:
bool isAnagram(string s, string t) {
//数组实现哈希法
int hash[26]={0};
for(int i=0;i<s.size();i++){
hash[s[i]-'a']++;
}for(int i=0;i<t.size();i++){
hash[t[i]-'a']--;
}for(int i=0;i<26;i++){
if(hash[i]!=0) return false;
}
return true;
}
};349. 两个数组的交集
题目链接 ：349. 两个数组的交集 - 力扣（LeetCode）
set适用于存储唯一且有序元素的情况。unordered_set 是一个无序集合，主要用于存储唯一的元素，并支持高效的插入、删除和查找操作。
(1)适用情况：
唯一元素集合：需要存储不重复的元素。
高效查找：需要快速判断某个元素是否存在于集合中。
无序存储：不关心元素的存储顺序，只关心集合中的元素。
(2)常见用法：
去除重复元素。
快速查找和判断元素是否存在。
处理集合运算（如交集、并集、差集）。
(3)基本用法（增删查改）
#include <iostream>
#include <unordered_set>
int main() {
// 创建一个unordered_set
std::unordered_set<int> mySet;
// 增：插入元素
mySet.insert(1);
mySet.insert(2);
mySet.insert(3);
// 查：查找元素
if (mySet.find(2) != mySet.end()) {
std::cout << "Element 2 found in set." << std::endl;
} else {
std::cout << "Element 2 not found in set." << std::endl;
}
// 删：删除元素
mySet.erase(2);
// 改：unordered_set 没有直接修改元素的操作
// 一般是先删再增
if (mySet.find(3) != mySet.end()) {
mySet.erase(3);
mySet.insert(30);
}
// 打印所有元素
for (const auto& elem : mySet) {
std::cout << elem << " ";
}
std::cout << std::endl;
return 0;
}
解题思路：将nums1中所有数值写入unordered_set类型的哈希表中，再遍历nums2，查找哈希表中是否存在相同数值，若存在则插入新的哈希表nums_set中，最后把nums_set转换为vector形式输出结果。
代码如下：
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> res_set;
unordered_set<int> nums_set(nums1.begin(),nums1.end());
for(int num:nums2){
if(nums_set.find(num)!=nums_set.end()){
res_set.insert(num);
}
}
return vector<int>(res_set.begin(),res_set.end());
}
};202. 快乐数
解题思路：出现以下情况，37经过一系列操作又变回37将会进入无限循环。
所以只需看每次计算的和在之前有没有出现过，若出现则一定无限循环。定义一个unordered_set哈希表，判断每次计算sum是否等于1，若不为1则继续比对该数是否出现在哈希表中，若未出现，插入哈希表，进行下一次sum的计算再重新比较。
具体代码如下：
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;
}else if(set.find(sum)!=set.end()){
return false;
}
else{
set.insert(sum);
}
n=sum;
}
}
};1. 两数之和
unordered_map 是一个无序映射，主要用于存储键值对，并支持高效的插入、删除和查找操作。键必须是唯一的。
(1)适用情况：
键值对存储：需要存储键值对数据。
高效查找：需要快速根据键查找对应的值。
无序存储：不关心键值对的存储顺序，只关心键和值的映射关系。
(2)常见用法：
字典（key-value）存储。
计数器（例如，统计单词出现频率）。
缓存实现。
(3)基本用法（增删查改）
#include <iostream>
#include <unordered_map>
int main() {
// 创建一个unordered_map
std::unordered_map<std::string, int> myMap;
// 增：插入键值对
myMap["one"] = 1;
myMap["two"] = 2;
myMap["three"] = 3;
// insert方法插入
// 插入单个元素，使用 std::pair
myMap.insert(std::pair<std::string, int>("one", 1));
// 插入单个元素，使用 std::make_pair
myMap.insert(std::make_pair("two", 2));
// 插入单个元素，使用花括号初始化器
myMap.insert({"three", 3});
// 查：查找键
if (myMap.find("two") != myMap.end()) {
std::cout << "Key 'two' found with value: " << myMap["two"] << std::endl;
} else {
std::cout << "Key 'two' not found." << std::endl;
}
// 删：删除键值对
myMap.erase("two");
// 改：修改值
if (myMap.find("three") != myMap.end()) {
myMap["three"] = 30;
}
// 打印所有键值对
for (const auto& pair : myMap) {
std::cout << pair.first << ": " << pair.second << std::endl;
}
return 0;
}
map返回key值和value值：
#include <iostream>
#include <map>
int main() {
// 创建并初始化一个map
std::map<std::string, int> myMap = {
{"one", 1},
{"two", 2},
{"three", 3}
};
// 遍历map并访问键和值
for (const auto& pair : myMap) {
std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
}
return 0;
}
解题思路：定义unordered_map类型哈希表，遍历数组，并查找哈希表中是否存在与之相加等于target的值，找到即返回哈希表value值，和数组下标值。若没有，将此数存入哈希表中，key值为数组值，value值为下标值。
具体代码如下：
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++){
atuo iter=map.find(target-nums[i]);
if(iter!=map.end()){
return {iter->second,i};
}
map.insert(pair<int int>(nums[i],i));
}
return {};
}
};