代码随想录算法训练营第六天 | 242.有效的字母异位词、 349.两个数组的交集、202.快乐数、1.两数之和

**

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

**

1、 哈希表理论基础

哈希函数hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，可以将信息映射为哈希表的索引数字了。

如果hashCode得到的数值大于 哈希表的大小了，也就是大于tableSize了，此时为了保证映射出来的索引数值都落在哈希表上，我们会在再次对数值做一个取模的操作。

因为哈希表是个数组，如果数量大于哈希表，此时就算哈希函数计算的再均匀，也避免不了会有几位学生的名字同时映射到哈希表 同一个索引下标的位置。

如果两个元素都索引到相同位置，此时出现的现象叫做哈希碰撞。
哈希碰撞的两种解决办法：拉链法和线性探测法

拉链法：就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。
线性探测法：一定要保证tableSize大于dataSize。 我们需要依靠哈希表中的空位来解决碰撞问题。

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

总结一下，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。
但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

2、有效的字母异位词

数组在哈希表中的经典应用

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

for (int i = 0; i < s.size(); i++) {  
    record[s[i] - 'a']++;  
}//这个循环遍历字符串s中的每个字符。对于每个字符，
//它计算该字符与'a'之间的差值（这实际上是利用了ASCII码值的特性，
//因为'a'到'z'的ASCII码值是连续的，所以'a'的ASCII码值减去它自身等于0，
//'b'的ASCII码值减去'a'的ASCII码值等于1，依此类推）。
//然后，它使用这个差值作为record数组的索引，并将对应元素的值增加1。
//这样，record数组就记录了字符串s中每个字母的出现次数。

3、两个数组的交集

用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

unordered_set 此数据结构可以直接内部去重，不需要额外处理。

unordered_set<int> nums_set(nums1.begin(), nums1.end()); 

这行代码创建了一个unordered_set（无序集合）nums_set，并使用nums1向量的起始迭代器（nums1.begin()）和终止迭代器（nums1.end()）作为参数，这样nums_set就包含了nums1中的所有元素，但因为是集合，所以每个元素都是唯一的，即重复的元素会被自动去除。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
    {
        unordered_set<int> result_set;
        unordered_set<int> num_set(nums1.begin(), nums1.end());
        for(int i = 0; i < nums2.size(); i++)
        {
            if(num_set.find(nums2[i]) != num_set.end())
            {
                result_set.insert(nums2[i]);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

4、快乐数

对于个位数的处理：模10运算 n%10获得n的各位数字，然后对n进行位数缩减（n/=10)

疑问点：int sum = getSum(n);中的sum已经在上卖弄的getsum函数中被赋值为各个位上数字的平方和了，为什么还要在while循环内再次赋值。

解答：在 isHappy 函数中，int sum = getSum(n); 这行代码位于 while 循环内部，意味着每次循环迭代时都会重新执行这个赋值操作。这是因为在判断快乐数的过程中，我们需要不断地更新 n 的值为其各个位上数字的平方和，并基于这个新的值进行下一次迭代。

利用unordered_set中的set.find成员函数

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;
            }
            if(set.find(sum) != set.end())//
            {
                return false;
            }else 
            {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

在 if (set.find(sum) != set.end()) 这个条件判断中，set.find(sum) 尝试在集合 set 中查找值为 sum 的元素。如果找到了，set.find(sum) 将返回一个指向该元素的迭代器；如果没有找到，它将返回 set.end()

这里的 set.end() 是一个迭代器，它指向集合中最后一个元素之后的位置，即一个“尾后”位置，表示集合的结束。

如果 set.find(sum) 返回的迭代器不等于 set.end()，说明集合中已经存在值为 sum 的元素，即我们之前已经计算过这个 sum 值了。这通常意味着我们已经进入了一个循环，因为我们在不断地对 n 进行操作，但得到的 sum 值却在重复出现。因此，我们可以断定这个数字不是一个快乐数，并返回 false。

如果 set.find(sum) 返回的迭代器等于 set.end()，说明集合中不存在值为 sum 的元素，即我们之前还没有计算过这个 sum 值。这意味着我们可以继续迭代过程，将 sum 添加到集合中以备将来检查，并更新 n 的值为 sum，以便在下一次迭代中继续计算。

5、两数之和

map可以在最短的时间内查看key是否在map中出现过

我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

map是一种key value的存储结构，可以用key保存数值，用value再保存数值所在的下标。

接下来需要明确两点：

map用来做什么
map中key和value分别表示什么

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）

这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

所以 map中的存储结构为 {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++) 
        {
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) 
            {
                return {iter->second, i};
            }
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

return {iter->second, i};
中的second访问的是map中的第二个键值，也就是value

例如 iter->first 访问的就是第一个键值，也就是 key