代码随想录算法训练营第6天｜【哈希表01】242.有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

今日任务
哈希表理论基础
242.有效的字母异位词349. 两个数组的交集 202. 快乐数1. 两数之和
状态：1刷

---

哈希表基础

定义

1. 一般哈希表都是用来快速判断一个元素是否出现集合里，要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。
   hash function ，也就是哈希函数
   hashFunction = hashCode(name) % tableSize
   数据规模是dataSize， 哈希表的大小为tableSize。

拉链法：发生冲突的元素都被存储在链表中。
线性探测法：要保证tableSize大于dataSize， 我们需要依靠哈希表中的空位来解决碰撞问题。
哈希碰撞：同时映射到一个位置
一般哈希碰撞有两种解决方法， 拉链法和线性探测法。

常见的三种哈希结构

数组
set （集合）
map (映射)

C++11标准：当我们要使用集合（set）来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

总结一下，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

unordered_set：使用哈希表，效率高，无重复，不用排序
std::unordered_map ：底层实现为哈希表，无序，不可重复。
std::map 和std::multimap 的底层实现是红黑树，map有序，不可重复；mutimap有序可重复。

---

一、242.有效的字母异位词

题目：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意，若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

思路： 数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。

代码：

// 哈希法
// 数组 用来做哈希表
class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++){
        // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[s[i] - 'a']++;
        }
        for (int i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        // record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        // 反之，true
        return true;
    }
};

时间复杂度: O(n)
空间复杂度: O(1)

---

二、349. 两个数组的交集

题目： 给定两个数组，编写一个函数来计算它们的交集，输出结果中的每个元素一定是唯一 的。我们可以不考虑输出结果的顺序 。
注：考虑什么时候用set 什么时候用数组？
思路： 输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序。而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。此时就要使用另一种结构体了，set ，关于set，C++ 给提供了如下三种可用的数据结构：
std::set
std::multiset
std::unordered_set
主要要学会使用一种哈希数据结构：unordered_set，使用哈希表，效率高，无重复，不用排序
代码：

// 主要要学会使用一种哈希数据结构：unordered_set
// finding the intersection of two arrays
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){
        // 是C++11 引入的一种新的for循环，被称为范围for循环或者for-each循环。
        // 遍历整个nums2向量，每次循环，num都会被赋值为nums2中的下一个元素
        // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()){
                // 这是一个unordered_set的成员函数，它尝试在nums_set中查找值为num的元素。
                // 检查find()函数返回的迭代器是否等于nums_set.end()。
                // 如果它们不相等，那就意味着find()函数找到了一个元素
                // 这行代码的总体含义就是：如果在nums_set中找到了元素num，执行接下来的语句。
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

This algorithm is quite efficient, taking linear time complexity O(N+M), where N and M are the sizes of the input vectors. The space complexity is also linear O(N+M) due to the use of extra data structures (two sets).
注：直接使用set 不仅占用空间比数组大，而且速度要比数组慢

---

三，202. 快乐数

题目： 编写一个算法来判断一个数 n 是不是快乐数。

思路： 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要。来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。
判断sum是否重复出现就可以使用unordered_set。

Code：

// 可能是无限循环
// 当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了
class Solution {
public:
    int getSum(int n){
        int sum = 0;
        while (n){
            sum += (n % 10) * (n % 10);
            n = n / 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while(1){
            int sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            // 没找到会返回 set.end(), 然后 insert (sum)
            if (set.find(sum) != set.end()) {// 在set中找到了，出现循环，退出
                return false;
            }else {
                set.insert(sum);// 没找到就插入sum
            }
            n = sum;
        }
    }
};
// 时间复杂度: O(logn)
// 空间复杂度: O(logn)

---

四，1. 两数之和

题目： 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

思路： 在本题中，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。
map 作用：用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的
因为查找的是元素，所以 key：元素，value：下标。
即：map中的存储结构为 {key：数据元素，value：数组元素对应的下标}

这段C++代码是一个解决“两数之和”问题的实现。它是这样工作的：

这个问题的描述是：给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

这段代码的逻辑是：

1. 创建一个空的unordered_map map，用来存储数组中已经遍历过的数字及其对应的索引。

2. 用一个for循环来遍历nums数组。

3. 在每一次迭代中，先检查map中是否存在一个元素，使得这个元素与当前元素的和等于target。这是通过map.find(target - nums[i])来实现的，target - nums[i]即是我们需要的那个数。

4. 如果找到了这样的元素（即iter != map.end()），那么返回这两个元素的索引。注意，由于我们是在插入当前元素之前就进行检查的，所以iter->second一定是比i小的，所以应该先返回。

5. 如果在map中没有找到这样的元素，就把当前元素nums[i]和它的索引i插入到map中。

6. 如果遍历完整个数组都没有找到符合条件的两个数，那么返回一个空的数组{}。

这个算法的时间复杂性是O(n)，因为我们只需要遍历一次数组。空间复杂性也是O(n)，因为在最坏的情况下，我们可能需要把整个数组都存储到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]); // iter是map里的值
            if(iter != map.end()) {// 找到了符合条件的
                return {iter->second, i};// 坐标，（first）是键（key），第二个元素（second）是值（value）。
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); // key：数据元素，value：数组元素对应的下标
        }
        return {};
    }
};

why auto
auto关键字使得无需明确写出迭代器的完整类型std::unordered_map<int, int>::iterator。编译器会自动推断出iter的类型，这样不仅可以减少代码的冗余，还可以避免由于类型错误而导致的编译错误。

另一个使用auto的理由是，如果将来更改了map的类型（比如从unordered_map改为map），那么你不需要修改iter的类型，编译器会自动帮你处理，这增加了代码的可维护性。

---

总结

1. 什么时候使用哈希法：当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。
2. 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
3. set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。
4. map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下标。