day06 | 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和-优快云博客

本文链接：https://blog.youkuaiyun.com/C_huamao/article/details/138874097

哈希表理论基础

建议：大家要了解哈希表的内部实现原理，哈希函数，哈希碰撞，以及常见哈希表的区别，数组，set 和map。
什么时候想到用哈希法，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。这句话很重要，大家在做哈希表题目都要思考这句话。

242.有效的字母异位词

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。
再遍历字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。
那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作

class Solution {
public:
    bool isAnagram(string s, string t) {

        // 仅包含小写字母，可以用数组当哈希表
        int record[26] = {0};
        // 先统计一个单词的字母
        for (int i = 0; i < s.size(); i++) {
            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) {
                return false;
            }
        }
        return true;

    }
};

题目链接/文章讲解/视频讲解： 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

349. 两个数组的交集

这是我一开始的思路，因为这道题给出了限制数值的大小。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int record[1001] = {0};
        set<int> res;
        for (int i = 0; i < nums1.size(); i++) {
            record[nums1[i]] = 1;
        }
        for (int i = 0; i < nums2.size(); i++) {
            if (record[nums2[i]]) {
                res.insert(nums2[i]);
            }
        }
        // 因为返回值的问题，需要转成动态数组
        return vector<int>(res.begin(), res.end());
    }
};

使用这种方法更高效
此时就要使用另一种结构体了，set ，关于set，C++ 给提供了如下三种可用的数据结构：

std::set
std::multiset
std::unordered_set

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表，使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_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());
        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());
    }
};

题目链接/文章讲解/视频讲解：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

202. 快乐数

class Solution {
public:
    // 累加每个位置上数字的平方和
    int nums_sum(int n) {
        int sum = 0;
        while (n)
        {   
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        // 也可能是 无限循环 但始终变不到 1
        // 需要判断是不是无限循环，也就是每次的平方和要用哈希表记录，如果出现过，就返回false
        unordered_set<int> record;
        while (n != 1)
        {
            n = nums_sum(n);
            if (record.find(n) != record.end()) {
                return false;
            } else {
                record.insert(n);
            }
        }
        return true;
    }
};

题目链接/文章讲解：https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html

1. 两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        // 返回它们的数组下标
        // 这题可以不用考虑顺序，unordered_map底层是哈希表
        unordered_map<int, int> map;
        // 那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，
        // 有key对应的就是value，value用来存下标。
        for (int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            // find(key);
            //查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回map.end();
            auto iter = map.find(target - nums[i]);
            // 如果找到了
            if (iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，那么就把访问过的元素和下标加入到map中
            map.insert({nums[i], i});
        }
        return {};
        
    }
};