专题三：哈希表

声明：

参考：代码随想录

个人总结归纳，仅用于复习回顾，不做他用！如发现文章内容有误，恳请批评指出！

目录

哈希表理论基础

一、哈希表(Hash table)

二、哈希函数

 三、哈希碰撞（哈希冲突）

 1、拉链法

2、线性探测法

 四、常见的三种哈希结构

题型一：有效的字母异位词

例1：242. 有效的字母异位词 - 力扣（LeetCode）

例2：383. 赎金信 - 力扣（LeetCode）

例3： 49. 字母异位词分组 - 力扣（LeetCode）

例4： 438. 找到字符串中所有字母异位词 - 力扣（LeetCode）

题型二：两个数组的交集 

例1： 349. 两个数组的交集 - 力扣（LeetCode）

 解法一：哈希表（unordered_set）

 解法二：哈希表（数组）

 例2：350. 两个数组的交集 II - 力扣（LeetCode）

 解法一：哈希表（unordered_map）

解法二：排序+双指针

题型三：快乐数

 例1：202. 快乐数 - 力扣（LeetCode）

题型四：两数之和

 例1：1. 两数之和 - 力扣（LeetCode）​编辑

题型五：四数相加Ⅱ 

例1： 454. 四数相加 II - 力扣（LeetCode）

题型六：三数之和

例1： 15. 三数之和 - 力扣（LeetCode）

例2： 18. 四数之和 - 力扣（LeetCode）

总结

哈希表理论基础

一、哈希表(Hash table)

有时也被称为散列表。

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

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

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

二、哈希函数

 三、哈希碰撞（哈希冲突）

 1、拉链法

2、线性探测法

 四、常见的三种哈希结构

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

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

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

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

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

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

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

其他语言例如：java里的HashMap ，TreeMap 都是一样的原理。可以灵活贯通。

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

这里在说一下，一些C++的经典书籍上 例如STL源码剖析，说到了hash_set hash_map，这个与unordered_set，unordered_map又有什么关系呢？

实际上功能都是一样一样的， 但是unordered_set在C++11的时候被引入标准库了，而hash_set并没有，所以建议还是使用unordered_set比较好，这就好比一个是官方认证的，hash_set，hash_map 是C++11标准之前民间高手自发造的轮子。

题型一：有效的字母异位词

例1：242. 有效的字母异位词 - 力扣（LeetCode）

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']++;//并不需要记住字符a的ASCⅡ，只要求出一个相对数值就可以了
        }
        for(int i = 0;i < t.size();i++){
            record[t[i] - 'a']--;
        }
        for(int i = 0;i < 26;i++){
            if(record[i] != 0){//record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        return true;//record数组所有元素都为零0，说明字符串s和t是字母异位词
    }
};
//哈希表（数组）
//时间复杂度O(n)
//空间复杂度O(1)

 数组就是简单的哈希表，但是数组的大小可不是无限开辟的

解题思路：

数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，大小为26 就可以了，初始化为0，来记录字符串s里字符出现的次数，因为字符a到字符z的ASCII也是26个连续的数值。

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。

最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

时间复杂度为O(n)，空间上因为定义是的一个常量大小的辅助数组，所以空间复杂度为O(1)。

例2：383. 赎金信 - 力扣（LeetCode）

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        if(ransomNote.length() > magazine.length()){
            return false;
        }
        for(int i = 0;i < magazine.length();i++){
            record[magazine[i] - 'a']++;// 通过recode数据记录 magazine里各个字符出现次数
        }
        for(int j = 0;j < ransomNote.length();j++){
            record[ransomNote[j] - 'a']--;// 遍历ransomNote，在record里对应的字符个数做--操作
            if(record[ransomNote[j] - 'a'] < 0){// 如果小于零说明ransomNote里出现的字符，magazine没有
                return false;
            }
        }
        return true;
    }
};
//哈希表（数组）
//时间复杂度O(n)
//空间复杂度O(1)

本题与例1.有效字母异位词很像，不同的是例1.有效字母异位词，相当于求字符串a 和字符串b是否可以相互组成 ，而本题求字符串a能否由字符串b组成，而不用管字符串b 能不能由字符串a组成。

本题判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成，但是这里需要注意两点。

• 第一点“为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思”  这里说明杂志里面的字母不可重复使用。

• 第二点 “你可以假设两个字符串均只含有小写字母。” 说明只有小写字母，这一点很重要

例3： 49. 字母异位词分组 - 力扣（LeetCode）

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string,vector<string>> record;//定义哈希表
        for(int i = 0; i < strs.size(); i++){//遍历字符串数组
            string key = strs[i];
            sort(key.begin(),key.end());//取出当前字符串，进行排序
            record[key].push_back(strs[i]);//将当前字符串放入哈希表
        }
        //将哈希表中的数组拼接返回
        vector<vector<string>> ans;
        for(auto it = record.begin(); it != record.end(); it++){
            ans.push_back(it->second);
        }
        return ans;
    }
};
//哈希表unordered_map
//时间复杂度O(nklogk)
//空间复杂度O(nk)

sort()函数：sort(begin, end, cmp)，其中begin为指向待sort()的数组的第一个元素的指针，end为指向待sort()的数组的最后一个元素的下一个位置的指针，cmp参数为排序准则，如果没有的话，默认以非降序排序。 

 遍历哈希表
for (vector<int>::iterator it = nums.begin(); it != nums.end(); it++)

例4： 438. 找到字符串中所有字母异位词 - 力扣（LeetCode）

 

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> res;
        if(s.size() < p.size()){
            return res;
        }
        vector<int> counts(26);//用数组counts记录字符串p中每个字母数量
        for(int i = 0; i < p.size(); i++){
            counts[p[i] - 'a']++;
        }
        for(int left = 0, right = 0; right < s.size(); right++){
            counts[s[right] - 'a']--;
            while(counts[s[right] - 'a'] < 0){
                counts[s[left] - 'a']++;
                left++;
            }
            if(right - left + 1 == p.size()){
                res.push_back(left);
            }
        }
        return res; 
    }
};
//滑动窗口+双指针
//时间复杂度O(n)
//空间复杂度O(1)

可变滑动窗口，在每次滑动过程中right向右移动一次，把counts中right对应的字母数量减一，一旦数量小于零，就不断右移left缩小窗口，并更新counts中对应字母的数量，直到right对应字母数量不再小于零为止。这样就保证了滑动过程中窗口中的每个字母出现次数一定不会多于字符串p中出现的次数。在该限制条件下，一旦滑动过程中左右指针的距离等于p字符串对应的长度，该窗口的字符串就一定是p字符串的异位词，将left存放在res，最后滑动过程结束后将res返回即可

题型二：两个数组的交集 

例1： 349. 两个数组的交集 - 力扣（LeetCode）

 解法一：哈希表（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){
            if(nums_set.find(num) != nums_set.end()){// 发现nums2的元素 在nums_set里又出现过
                result_set.insert(num);
            }
        }
        return vector<int> (result_set.begin(),result_set.end());
    }
};
//哈希表unordered_set
//时间复杂度O(n)
//空间复杂度O(1)

 解法二：哈希表（数组）

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;// 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0};// 默认数值为0
        for(int num : nums1){// nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for(int num : nums2){
            if(hash[num] == 1){// nums2中出现相同值，用result记录
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};
//哈希表（数组）
//时间复杂度O(n)
//空间复杂度O(1)

 例2：350. 两个数组的交集 II - 力扣（LeetCode）

 ​​​​​​

 解法一：哈希表（unordered_map）

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        if(nums1.size() > nums2.size()){
            return intersect(nums2,nums1);
        }
        unordered_map<int,int> map;
        for(int num : nums1){
            map[num]++;
        }
        vector<int> result;
        for(int num : nums2){
            if(map.count(num)){
                result.push_back(num);
                map[num]--;
                if(map[num] == 0){
                    map.erase(num);
                }
            }
        }
        return result;
    }
};
//哈希表（unordered_map）
//时间复杂度O(m+n)
//空间复杂度O(min(m,n))

解法二：排序+双指针

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        int length1 = nums1.size(),length2 = nums2.size();
        vector<int> result;
        int p1 = 0, p2 = 0;
        while(p1 < length1 && p2 < length2){
            if(nums1[p1] < nums2[p2]){
                p1++;
            }else if(nums1[p1] > nums2[p2]){
                p2++;
            }else{
                result.push_back(nums1[p1]);
                p1++;
                p2++;
            }
        }
        return result;
    }
};
//排序+双指针
//时间复杂度O(m+n)
//空间复杂度O(min(m,n))

题型三：快乐数

 例1：202. 快乐数 - 力扣（LeetCode）

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;
            }
            //如果这个sum曾经出现过，说明已经陷入了无限循环，立刻return false
            if(set.find(sum) != set.end()){
                return false;
            }else{
                set.insert(sum);
            }
            n = sum;
        }
    }
};
//哈希表（unordered_set）
//时间复杂度O(n)
//空间复杂度O(n)

题型四：两数之和

 例1：1. 两数之和 - 力扣（LeetCode）

 

 

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> map;
        for(int i = 0; i < nums.size(); i++){
            //遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]);
            if(iter != map.end()){
                return {iter->second,i};
            }
            //如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int,int>(nums[i],i));
        }
        return {};
    }
};
//哈希表（unordered_map）
//时间复杂度O(n)
//空间复杂度o(n)

题型五：四数相加Ⅱ 

例1： 454. 四数相加 II - 力扣（LeetCode）

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> map;//key：num1+num2的数值，value：num1+num2数值出现的次数
        //遍历nums1和nums2数组，统计两个数组元素之和，和出现的次数，放到map中
        for(int num1 : nums1){
            for(int num2 : nums2){
                map[num1 + num2]++;
            }
        }
        int count = 0;//统计num1+num2+num3+num4 = 0出现的次数
        //在遍历nums3和nums4数组，找到如果0-(c+d)在map中出现过的话，就把map中key对应的value也就是出现次数统计出来
        for(int num3 : nums3){
            for(int num4 : nums4){
                if(map.find(0 - (num3 + num4)) != map.end()){
                    count += map[0 - (num3 + num4)];
                }
            }
        }
        return count;
    }
};
//哈希表（unordered_map）
//时间复杂度O(n^2)
//空间复杂度O(n)

题型六：三数之和

例1： 15. 三数之和 - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());//非降序排序
        //找出 a + b + c = 0
        //a = nums[i] , b = nums[left] , c = nums[right]
        for(int i = 0; i < nums.size(); i++){
            //排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果即可
            if(nums[i] > 0){
                return result;
            }
            //去重a
            if(i > 0 && nums[i] == nums[i - 1]){
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left){
                if(nums[i] + nums[left] + nums[right] > 0){
                    right--;
                }else if(nums[i] + nums[left] + nums[right] < 0){
                    left++;
                }else{
                    result.push_back(vector<int>{nums[i] , nums[left] , nums[right]});
                    //去重逻辑应该放在找到一个三元组之后，对 b 和 c 去重
                    while(right > left && nums[right] == nums[right - 1]){
                        right--;
                    }
                    while(right > left && nums[left] == nums[left + 1]){
                        left++;
                    }
                    //找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};
//双指针
//时间复杂度O(n^2)
//空间复杂度O(1)

 

例2： 18. 四数之和 - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        for (int k = 0; k < nums.size(); k++) {
            //剪枝处理
            if (nums[k] > target && nums[k] >= 0) {
                break;//这里使用break，统一通过最后的return返回
            }
            //对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                //二级剪枝处理
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }
                //对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (right > left) {
                    //nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出，加long防止整型溢出越界的问题
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    }
                    //nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出，加long防止整型溢出越界的问题
                    else if ((long) nums[k] + nums[i] + nums[left] + nums[right] < target) {
                        left++;
                    }
                    else {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        //对nums[left]和nums[rught]去重
                        while (right > left && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        while (right > left && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        //找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                } 
            }
        }
        return result;
    }
};
//双指针
//时间复杂度O(n^3)
//空间复杂度O(1)

总结