力扣LeetCode-哈希表

哈希表

一、基本知识点

1. 定义

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

2. 解决问题

快速判断一个元素是否出现集合里。

3. 哈希碰撞解决方法

拉链法与线性探测法。

4. 常见的三种哈希结构

• 数组

• set（集合）

• map（映射）

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(logn)	O(logn)
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(logn)	O(logn)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的。

虽然std::set、std::multiset 的底层实现是红黑树，不是哈希表，但是std::set、std::multiset 依然使用哈希函数来做映射，只不过底层的符号表使用了红黑树来存储数据，所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。 map也是一样的道理。

二、典型例题

1. Leetcode49. 字母异位词分组

题目

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母都恰好只用一次。

来源：力扣（LeetCode） 链接：力扣

解法一 利用素数标志特征值

思路

1. 建立一个长度26数组存储最小的26个素数，对应26个英文字母；

2. 设置一个flag数组用于记录每一类字符串的特征值（字符串所有字母对应素数之积），其下标与最终结果每一类字符创下标对应；

3. 从字符串数组开始计算每个字符串的特征值（每个字母对应素数之积），而后在flag数组中查找该特征值，如若找到则将该字符串添加到flag值对应下标的最终结果字符串类，如果没有找到，则在最终结果字符串类中创建一个新字符串类，并且在flag数组中添加相同对应下标的特征值，保证result每一类字符串与flag数组特征值对应下标相同实现也十分简单，只需两者同步更新添加，并且都向最后添加新创建的字符串类即可；

代码

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> result;
        vector<int> flag;   //记录每一类字符串的特征值（所有字母对应素数之积）
        int big_sushu = 1e9+7;  //一个比较大的素数
        int sushu[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67, 71, 73,79,83,89,97,101};  //26个素数对应26个英文字母
        for(int i=0; i<strs.size(); i++){
            int sum = 1;
            for(int j=0; j<strs[i].size(); j++){
                sum = ((long long)sum*sushu[strs[i][j]-'a']) % big_sushu;  //防止乘积过大越界
            }
            int j;
            for(j=0; j<flag.size(); j++){  //判断之前有无与之同类的字符串
                if(sum == flag[j])
                    break;
            }
            if(j!=flag.size()){   //如果有，添加到同一类
                result[j].push_back(strs[i]);
            }
            else{     //如果没有，创建一个该类的字符串数组，并将特征值添加到flag数组
                flag.push_back(sum);
                vector<string> temp;
                temp.push_back(strs[i]);
                result.push_back(temp);
            }
        }
        return result;
    }
};

解法二 哈希表

思路

1. 创建一个map，其值用来存储同一类型字符串数组，其key值为按字母升序排序后字符串；

2. 遍历字符串数组，将其按字母升序排列后作为特征值，从map中匹配特征值并添加到相应类；

3. 将map中的每个值添加到最终字符串数组中；

代码

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> res;
        unordered_map<string,vector<string>> map;
        for(int i=0;i<strs.size();++i){
            string key=strs[i];
            sort(key.begin(),key.end());
            map[key].push_back(strs[i]);
        }
        for(auto a: map) res.push_back(a.second);
        return res;
    }
};

2. LeetCode438. 找到字符串中所有字母异位词

题目

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

思路（滑动窗口）

1. 设置两个长度为26的数组，一个用于存储目标字符串字符，一个用于记录滑动窗口内字符个数

2. 设置left与right并且窗口长度保持为目标字符串长度，left从长字符串左端开始移动，right随left右移随之右移，每移动一次进行一次判断，成功匹配则记录left值。

代码

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        if(s.size()<p.size())
            return {};
        int l = 0, r = -1;
        vector<int> freq_s(26, 0), freq_p(26, 0), res;
        for( int i = 0 ; i < p.size() ; i++ ){
            freq_p[p[i] - 'a' ]++;
            freq_s[s[++r] - 'a' ]++;
        }
        if ( freq_s == freq_p )
            res.push_back( l );
        // 固定长度的滑动窗口
        while( r < s.size()-1 ){
            freq_s[s[++r] - 'a' ]++;
            freq_s[s[l++] - 'a' ]--;
            if ( freq_s == freq_p )
                res.push_back( l );
        }
        return res;
    }
};

3. LeetCode202. 快乐数

题目

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

「快乐数」定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。 如果 可以变为 1，那么这个数就是快乐数。 如果 n 是快乐数就返回 true ；不是，则返回 false

来源：力扣（LeetCode） 链接：力扣

思路

1. 首先编写一个求取一个数各个位平方和函数；

2. 设置一个vector变量用于记录每步中变量的值，若新计算得到的变量位于vector中，则说明计算发生循环，进而最初的数不是快乐数，如果在计算过程中判断变量与1相等，说明最初的数为快乐数。

代码

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

4. Leetcode1.两数之和

题目

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

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

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

来源：力扣（LeetCode） 链接：力扣

思路

1. 创建一个map映射，其key存储数组某一项，其value为其下标；

2. 顺序访问数组，在map中查找target-nums[i]，如果找到则返回当前下标与map对应项的第二项值，如果没有找到则将数组当前项值与下标存储进map；

3. 如果找到则中途return，若未找到则最后返回空；

4. 之所以可以边加入边寻找有一个关键点，即两个数之和为一个定值，则这两个数互相寻找对方值是一个对称关系，则在找到其中一个数时，另一个数未出现不返回，而在找到第二个数时，第一个数已经存在，所以可以返回。

代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        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};
            }
            else{
                map.insert(pair<int, int>(nums[i], i));
            }
        }
        return {};
    }
};

5. Leetcode454.四数相加 2

题目

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

来源：力扣（LeetCode） 链接：力扣

思路

1. 此题元组默认可以重复，所以可以使用以下方法求解；

2. 设置一个map映射，其key为nums1与nums2中分别取一数之和，其value为这两数和出现的次数；

3. 两层循环遍历nums1与nums2完善map映射；

4. 两层循环遍历nums3与nums4，在map中寻找其和的相反数，如果找到则说明最终匹配数增加map中所找项的value。

代码

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int>map;
        for(int a:nums1){
            for(int b:nums2){
                map[a+b]++;
            }
        }
        int count=0;
        for(int c:nums3){
            for(int d:nums4){
                if(map.find(0-(c+d)) != map.end()){
                    count += map[0-(c+d)];
                }
            }
        }
        return count;
    }
};

6. LeetCode15.三数之和

题目

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

来源：力扣（LeetCode） 链接：力扣

思路（滑动窗口）

1. 首先对nums数组进行排序，使得后面可以对搜索进行剪枝操作；

2. 外层设置大循环，为遍历a元素，而在每次循环中，对a之后元素设置left=i+1与right=nums.size()-1，在left<right情况下，进行left++与right--使得可以遍历所有三元组；

3. 循环中的剪枝操作

   1. 在a的每次循环时，如果a>0，则a之后的left与right一定大于0，则不可能找到和为0的元组，直接返回；

   2. 同时如果a与上次循环a相同，则可认为上一次循环已经找出本次循环所有可能解，如果继续寻找则会发生三元组重复（由于nums已经排序，所以只需比较上次）；

   3. 在每次找到符合要求的三元组时，left与right都需要移动至与原来值不同的位置，否则如果仅一个移动，根据三数之和为0，其实另一个数也是确定的，会导致三元组重复；

代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>>result;
        sort(nums.begin(), nums.end());
        for(int i=0; i<nums.size(); i++){
            if(nums[i]>0)
                return result;
            if(i>0 && nums[i] == nums[i-1]){
                continue;
            }
            int left = i+1;
            int right = nums.size()-1;
            while(left<right){
                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]});
                    while(left < right && nums[right]==nums[right-1]) right--;
                    while(left < right && nums[left]==nums[left+1]) left++;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

7. LeetCode18.四数之和

题目

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n a、b、c 和 d 互不相同 nums[a] + nums[b] + nums[c] + nums[d] == target 你可以按 任意顺序 返回答案 。

来源：力扣（LeetCode） 链接：力扣

思路

1. 整体思路与三数之和大致相同，比之增加一层循环，不过有些注意点与三数之和稍有不同；

2. 首先每次循环中不能再判断a>0就直接返回，因为本次target为任意值，当然也不能判断a>target进行返回，这同样会有问题，因为target可能为负数，当已判断a>target时，a之后的负数与a这个负数相加仍然可以等于target值，不能进行剪枝操作；

3. 同时注意，四个数分别可能并未超过int最大表示范围，但之和可能超过，需要强制类型转化进行判断操作；

4. 从本题中还发现一个重要点，对于vector的size（）函数返回值为unsigned int类型，当nums.size()值为1时，采用语句nums.size()-2会变为一个非常大的数，是因为nums.size()-2这个表达式值类型与nums.size()类型相同，当其变为负数时，实际在内存中存储的为该数的补码，而由于类型仍然为unsigned int，读取方式仍以此类型，所以读取后所得数值会很大。

代码

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for(int i=0; i<nums.size(); i++){
            if(i>0 && nums[i]==nums[i-1])
                continue;
            for(int j=i+1; j<(int)nums.size()-2; j++){
                if(j>i+1 && nums[j]==nums[j-1])
                    continue;
                int left = j+1;
                int right = nums.size()-1;
                while(left < right){
                    if((long long) nums[i]+nums[j]+nums[left]+nums[right] > target)
                        right--;
                    else if((long long) nums[i]+nums[j]+nums[left]+nums[right] < target)
                        left++;
                    else{
                        result.push_back(vector<int>{nums[i], nums[j], 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 result;
    }
};