代码随想录训练营第五天|第三章 哈希表part01

力扣242 有效的字母异位词

题目链接/文章讲解/视频讲解： 代码随想录

思路：定义哈希数组记录字符串中每个字母的出现次数，每出现一次对映射的下标的值加一。然后再将另一个数组循环遍历，字母每出现一次对哈希数组中映射的下标的值减一。然后整体看数组中的所有值是否清零。

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 两个数组的交集

题目链接/文章讲解/视频讲解：代码随想录

思路：学习使用了unordered_set这种数据类型，可以自动去重。只需要将其中一个数组存入这种数据类型中，然后遍历数组二查找是否有交集，然后返回交集。这里返回时需要将set类型转换为vector类型。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for(int num: nums2)
        {
            if(nums_set.find(num) != nums_set.end())
            {
                result.insert(num);
            }
        }
        return vector<int>(result.begin(), result.end());
    }
};

在这段代码中我不太理解

 if(nums_set.find(num) != nums_set.end())

查阅后得知

1. nums_set: 这是一个 std::set 对象，它是一个基于红黑树的数据结构，可以存储唯一的元素，并且这些元素在集合中是自动排序的。

2. .find(num): find 是 std::set 的一个成员函数，它尝试在集合中查找指定的元素。如果找到了元素，它会返回一个指向该元素的迭代器（iterator）；如果没找到，它会返回一个特殊的迭代器，即 nums_set.end()，这个迭代器指向集合的末尾的虚拟位置。

3. nums_set.end(): 这个表达式返回一个迭代器，表示集合中最后一个元素的下一个位置，通常用来表示集合的结束。

4. !=: 这是一个不相等运算符，用于比较 nums_set.find(num) 返回的迭代器是否不等于 nums_set.end()。

5. if: 这是一个条件语句，如果条件为真（即找到了元素），那么它会执行它后面的代码块。

所以，整体上，if(nums_set.find(num) != nums_set.end()) 这段代码是用来检查 num 是否存在于 nums_set 中。如果存在，find 方法会返回一个指向该元素的迭代器，这个迭代器不等于 nums_set.end()，因此条件为真，if 语句后面的代码块会被执行。如果 num 不在 nums_set 中，find 方法会返回 nums_set.end()，条件为假，if 语句后面的代码块不会被执行。

力扣202 快乐数 

题目链接/文章讲解：代码随想录

思路：题目说

重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。

说明sum的值要么变为1，要么会无限循环。一开始没有发现这个突破口。可以用set的数据结构存放sum值，如果为1则返回true，同时每插入一个新的sum值前检查是否已经插入过相同的sum值，如果是，则说明陷入无限循环，返回false。

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> result;
        while(1){
            int sum = getSum(n);
            if(sum == 1){
                return true;
            }
            if(result.find(sum) != result.end())
            {
                return false;
            }
            else
            {
                result.insert(sum);
            }
            n = sum;
        }
    }
};

 力扣1 两数之和

题目链接/文章讲解/视频讲解：代码随想录

暴力法：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {

        for(int i = 0; i < nums.size()-1; i++){
            int sub = target - nums[i];
            for(int j = i+1; j < nums.size(); j++)
            {
                if(nums[j] == sub){
                    return{i,j};
                }
            }
        }
        return {};
    }
};

哈希法：遍历数组，将遍历过的元素及下标存入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++){
            auto iter = map.find(target - nums[i]);
            if(iter != map.end()){
                return{iter->second, i};
            }
            map.insert(pair<int,int> (nums[i],i));
        }
        return {};
    }
};

对代码的一些解释：

• iter 是一个迭代器，指向 unordered_map 中的一个元素。
• iter->first 访问该元素的键（key）。
• iter->second 访问该元素的值（value）。

 在C++中，unordered_map 提供了一个方法 insert 来将键值对插入到哈希表中。insert 方法有多种重载方式，可以插入单个元素、范围内的元素，或者通过移动插入元素。map.insert(pair<int, int>(nums[i], i)); 是其中一种插入单个元素的方式，使用了 pair 来构造键值对。

1. 创建键值对：

   • pair<int, int>(nums[i], i) 创建一个 pair 对象，其第一个元素是 nums[i]，第二个元素是 i。
   • pair 是 C++ 标准库中的一个模板类，用于存储一对值，pair<first_type, second_type>。

2. 插入键值对：

   • map.insert(pair<int, int>(nums[i], i)) 将上述创建的 pair 对象插入到 unordered_map 中。
   • unordered_map 使用哈希表来存储键值对，因此插入操作通常是常数时间复杂度 O(1)。