代码随想录跟练日记|Day6 哈希表part01

算法小白训练营日记，笔记为自用，若有错误感谢指出

--今日任务--：哈希表理论基础， 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. 快乐数

题目链接：202. 快乐数 - 力扣（LeetCode）

解题思路：出现以下情况，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. 两数之和

题目链接：1. 两数之和 - 力扣（LeetCode）

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 {};
    }
};