代码随想录Day6 | 哈希表理论基础、242.有效的字母异位词、349.两个数组的交集、202.快乐数、1.两数之和

哈希表理论基础

哈希表

哈希表是根据关键码的值而直接进行访问的数据结构

其实数组就是一张哈希表，关键码就是数组的索引下标，通过下标直接访问数组元素。

一般哈希表用来快速判断一个元素是否出现在集合里。例如查询一个名字是否在这个学校，枚举的话复杂度是O(n)，但使用哈希表O(1)就能做到，只需要把这所学校所有名字都存在哈希表里，在查询的时候通过索引就可以知道这个同学在不在学校里。

将学生姓名映射到哈希表上就涉及到哈希函数。

哈希函数

哈希函数，把学生姓名直接映射为哈希表上的索引，然后可以通过查询索引下标快速知道这位同学是否在这所学校里了。

哈希函数如下所示，通过hashCode把名字转化为数值，这样就可以把学生名字映射为哈希表上的索引数字了。

为了保证映射出来的索引数值都落在哈希表上，我们会在再次对数值做一个取模的操作，这样我们就保证了学生姓名一定可以映射到哈希表上了。

此时问题又来了，哈希表我们刚刚说过，就是一个数组。

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

哈希碰撞

两个不同的名字都映射到的同一个索引位置，这一个现象叫做哈希碰撞

一般哈希碰撞有两种解决办法：拉链法和线性探测法。

拉链法：

刚刚小李和小王在索引1的位置发生了冲突，发生冲突的元素都被存储在链表中。 这样我们就可以通过索引找到小李和小王了

（数据规模是dataSize， 哈希表的大小为tableSize）

其实拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。

线性探测法：

使用线性探测法，一定要保证tableSize大于dataSize。 我们需要依靠哈希表中的空位来解决碰撞问题。

例如冲突的位置，放了小李，那么就向下找一个空位放置小王的信息。所以要求tableSize一定要大于dataSize ，要不然哈希表上就没有空置的位置来存放 冲突的数据了。如图所示：

常见的三种哈希结构：数组、set、map

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

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

那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

虽然std::set和std::multiset 的底层实现基于红黑树而非哈希表，它们通过红黑树来索引和存储数据。不过给我们的使用方式，还是哈希法的使用方式，即依靠键（key）来访问值（value）。所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。std::map也是一样的道理。

242.有效的字母异位词

暴力解法：

class Solution {
public:
    bool isAnagram(string s, string t) {       
        for (size_t i = 0; i < s.length(); ++i) {
        bool found = false;
        for (size_t j = 0; j < t.length(); ++j) {
            if (t[j] == s[i]) {
                t[j] = '*';  // 标记已访问
                found = true;
                break;
            }
        }
        if (!found) {
            return false;
        }
    }
    return true;
    }
};

对于s中的每一个字符，循环遍历t看有无相同的字符，如果找到标记为"*"，以确保重复元素比较的正确性。

考虑用哪种哈希结构？

本题字符串都由小写字母组成(a~z)，是连续的26个数，所以可以映射到数组上。**因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。**再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

思路：统计第一个字符串里每个字母出现的频率，在遍历第二个字符串时每个字母出现再做减法，这样如果最后哈希数组里面所有元素都是0，说明是有效的字母异位词。

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

349.两个数组的交集

考虑用什么数据结构？

因为题目要求要去重，所以可以使用set天然去重(set中不允许出现重复元素)，又因为不要求顺序等，所以用unordered_set，查询效率更快。

用set解决：

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

用数组解决：

总体思路就是将第一个数组中的元素对应下标的哈希表数值定义为1，其余为0，然后遍历第二个数组，通过判断哈希表数值是否为1来判断是不是第一个数组出现过的数字，如果是就是交集的一部分。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
       int hash[1005]={0};
       unordered_set<int> result;
       for(int num:nums1)
       {
        hash[num]=1;
       }
       for(int num:nums2)
       {
        if(hash[num]==1)
        {
            result.insert(num);
        }
       }
       return vector<int>(result.begin(),result.end());
    }
};

202.快乐数

思路：使用哈希法，判断sum是否在数组中重复出现，如果重复出现说明陷入了死循环，不会出现sum=1；如果没有重复出现就一直一直循环，直到sum=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> 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.两数之和

map的作用： 用来存放已经遍历过的元素，其中key存放元素值，value存放下标。

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

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

所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。

class Solution {
public:
   vector<int> twoSum(vector<int>& nums, int target) {
       unordered_map<int,int> map;
       for(int i=0;i<nums.size();i++)
       {
           int s=target-nums[i];
           unordered_map<int,int>::iterator it=map.find(s);
           if(it!=map.end())
           {
               return {it->second,i};
           }
           else
           {
               map.insert(make_pair(nums[i],i));
           }
       }
       return {};
   }
};