3.哈希表

janedipan

已于 2024-08-08 18:45:40 修改

阅读量581

点赞数 16

分类专栏：数据结构文章标签：哈希算法数据结构

于 2024-06-11 18:45:00 首次发布

本文链接：https://blog.csdn.net/weixin_43831098/article/details/139596762

版权

数据结构专栏收录该内容

10 篇文章 1 订阅

订阅专栏

3.哈希表

基础知识
- 哈希碰撞
- 常见哈希表的三种结构
题目
总结

基础知识

哈希表（英文名字为Hash table，国内也有一些算法书籍翻译为散列表，大家看到这两个名称知道都是指hash table就可以了）那么哈希表能解决什么问题呢，一般哈希表都是用来快速判断一个元素是否出现集合里。
枚举的话时间复杂度是O(n)，但如果使用哈希表的话，只需要O(1)就可以做到。
哈希函数
哈希函数如下图所示，通过hashCode把名字转化为数值，一般hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就把学生名字映射为哈希表上的索引数字了。

哈希碰撞

当两个以上不同元素都映射到hashtable同一个区域，就发生了哈希碰撞。

拉链法：将发生冲突的元素都被存储在链表中，其实拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。
线性探测法：依靠哈希表中的空位来解决碰撞问题。找一个空位放置冲突元素，所以要求tableSize一定要大于dataSize，要不然哈希表上就没有空置的位置来存放冲突的数据了。

常见哈希表的三种结构

1.vector数组
2.set集合
3.map键值对
set数据类型
当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset；
std::unordered_set是一个基于哈希表的容器，它存储了唯一的元素，而该类的方法find() 函数接受一个值作为参数，并返回一个迭代器，指向容器中与该值匹配的元素。如果元素不存在，则返回一个指向end()的迭代器，表示容器的末尾。

map数据类型
在map 是一个<key, value>的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

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

题目

1.有效字母异位词

题目链接
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。字母种类和数量一致，但字母排列的顺序不一致。说明：你可以假设字符串只包含小写字母。
这题是字符串的字符判断，题目假设都是小写字母，因此可以使用vector作为hash表容器。

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26] = {0};
        for(char word: s){
            hash[word-'a']++;
        }
        for(char word: t){
            hash[word-'a']--;
        }
        for(int i=0; i<26; i++){
            if(hash[i]!=0) return false;
        }
        return true;
    }
};

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

2.两个数组的交集

题目链接
给定两个数组，编写一个函数来计算它们的交集
本题后面力扣改了题目描述和后台测试数据，增添了数值范围：
1.1 <= nums1.length, nums2.length <= 1000
2.0 <= nums1[i], nums2[i] <= 1000
设计两次for遍历两个数组，使用arr[1001]数组对出现在一个数组中的数值的位置+1，然后在第二个数组遍历时对重复出现的数值添加进unordered_set中。
这题因为给出数组中每个数值的范围，因此可以使用vector作为hash容器：

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

时间复杂度: $O (n + m) m$ 是最后要把 set转成vector；空间复杂度: $O (n)$

3.快乐数

题目链接
编写一个算法来判断一个数 n 是不是快乐数。「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。

需要设计一个子函数，计算该数每个位置上数字的平方和；
所以设计while循环，当sum=1时，即可退出循环；当sum重复出现时(每次数值计算的重复性检测就需要set来判断)，说明此时无限循环，亦可退出循环；

class Solution {
public:
    bool isHappy(int n) {
        int cur = n;
        unordered_set<int> visited;
        while(cur!=1){
            int tmp = cur;
            int sum = (tmp%10)*(tmp%10);
            while(tmp/10){
                tmp = tmp/10;
                sum += (tmp%10)*(tmp%10);
            }
            if(visited.find(sum)==visited.end()){
                visited.insert(sum);
                cur = sum;
            }
            else return false;
        }
        return true;
    }
};

时间复杂度: $O (l o g n)$ ；空间复杂度: $O (l o g n)$

4.两数之和

题目链接
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
本题仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key-value结构来存放，key来存元素，value来存下标，那么使用map正合适。该题目题目中并不需要key有序，选择std::unordered_map 效率更高！
遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中。这样的只需遍历一次数组就可得出结果。
这题是要求数组中存在两个数之和等于目标值，而题目假定结果唯一（不存在多解的情况），因此一次遍历即可。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> visited;
        vector<int> res(0, 2);
        for(int i=0; i<nums.size(); i++){
            if(visited.find(target-nums[i])==visited.end()){
                visited[nums[i]]=i;
            }
            else{
                res={visited[target-nums[i]], i};
                return res;
            }
        }
        return res;
    }
};

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

5.四数相加（中等）

题目链接
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。而且为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。
该题思路是将四数相加问题转变为两个两数相加问题，首先使用一个map记录任意两个数组的和的值出现次数，然后在另外两个数组和的遍历情况中就这map进行和为0的次数判断

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int len = nums1.size();
        int res = 0;
        unordered_map<int, int> map1;
        for(int i=0; i<len; i++){
            for(int j=0; j<len; j++){
                map1[nums1[i]+nums2[j]]++;
            }
        }

        for(int i=0; i<len; i++){
            for(int j=0; j<len; j++){
                if(map1.find(-nums3[i]-nums4[j])!=map1.end()) res += map1[-nums3[i]-nums4[j]];
            }
        }
        return res;
    }
};

时间复杂度: $O(n^2)$ ；空间复杂度: $O(n^2)$ ，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2

6.赎金信

题目链接
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。
使用std::unordered_map记录magazein中出现的字母编码以及次数，然后在ransom遍历时查找在unordered_map中对应字母编码是否出现以及次数。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26]{0};
        for(char word:magazine){
            hash[word-'a']++;
        }
        for(char word:ransomNote){
            if(hash[word-'a']==0) return false;
            hash[word-'a']--;
        }
        return true;
    }
};

时间复杂度: $O(n^2)$ ；空间复杂度: $O (1)$

7.三数之和（中等）

题目链接
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组
需要使用快速排序法对nums数据进行数值大小的排序。
1.暴力解法：使用两层for循环遍历a，b，然后记录a+b的值（其过程注意去重），然后使用类似两数之和的方式，对第三个数使用unordered_set记录（但也会遇到去重的问题）。去重的过程不好处理，有很多小细节，如果在面试中很难想到位。
2.双指针解法：使用一个for循环，从数组最左端出发，以此作为数值a，剩余的n-1的子数组左，右端分别设置L_p, R_p两个指针通过while(L_p<R_p)循环，尝试不同的b+c组合。注意a，b，c的去重处理。
在这里插入图片描述
求返回不重复的三元组，就必须考虑去重问题，去重问题就必须先对数组进行排序，令相同数值相邻排序（方便）；

class Solution {
public:
	// 双指针法-去重过程很直观
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        unordered_map<int, int> hash;
        sort(nums.begin(), nums.end());
        for(int i=0; i<nums.size(); i++){
            // 对第一个数值去重
            if(i>0 && nums[i]==nums[i-1]) continue;
            int left = i+1;
            int right = nums.size()-1;
            while(left<right){
                if(nums[left]+nums[right]>-nums[i]) right--;
                else if(nums[left]+nums[right]<-nums[i]) left++;
                else{
                    res.push_back({nums[i], nums[left], nums[right]});
                    // 对第二，三个数值去重
                    while(left<right && nums[right]==nums[right-1]) right--;
                    while(left<right && nums[left]==nums[left+1]) left++;
                    right--;
                    left++;
                }
            }
        }
        return res;
    }
};

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[j], c = -(a + b)
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
                continue;
            }
            unordered_set<int> set;
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2
                        && nums[j] == nums[j-1]
                        && nums[j-1] == nums[j-2]) { // 三元组元素b去重
                    continue;
                }
                int c = 0 - (nums[i] + nums[j]);
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c});
                    set.erase(c);// 三元组元素c去重
                } else {
                    set.insert(nums[j]);
                }
            }
        }
        return result;
    }
};

时间复杂度: $O(n^2)$ ；空间复杂度: $O (1)$

8.四数之和

题目链接
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组：

1 <= nums.length <= 200
-10(9) <= nums[i] <= 10(9)
-10(9) <= target <= 10(9)
注意 a,b,c,d的去重操作；注意 整数加法超过int的范围，需要在运算语句前加入(long)。
这道题与上一题的三数之和如法炮制，最核心的还是双指针法（负责三号，四号位数值的确定），相比于三数之和，这里需要在顶层多一个对二号位数值的确定的循环：

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++) {
                // 2级剪枝处理
                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 会溢出
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    } 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[right]去重
                        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)$

总结

一般来说哈希表都是用来快速判断一个元素是否出现集合里。
对于哈希表，要知道哈希函数和哈希碰撞在哈希表中的作用。

哈希函数是把传入的key映射到符号表的索引上。
哈希碰撞处理有多个key映射到相同索引上时的情景，处理碰撞的普遍方式是拉链法和线性探测法。

数组作为哈希表
一些应用场景就是为数组量身定做的，例如一些考虑到字母（ASCII编码）的问题，此时可以使用数组组成简单的哈希表。

数组的大小是有限的，受到系统栈空间（不是数据结构的栈）的限制。
如果数组空间够大，但哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。
set作为哈希表
用unordered_set 读写效率是最高的，适合用于并不需要对数据进行排序，而且还不要让数据重复的情况
数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。
map作为哈希表
map是一种<key, value>的结构，本题可以用key保存数值，用value在保存数值所在的下标。
通常可以用来解决一些三数之和，四数之和等的问题