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

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

哈希表理论基础

哈希表(Hash table)，是根据关键码的值而直接进行访问的数据结构（官方解释）

通俗来说，数组就是一张哈希表

哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素，如图

哈希表作用：一般哈希表都是用来快速判断一个元素是否出现集合里

举例：查询一个名字是否在这所学校内

枚举的话，时间复杂度是 O(n)，但如果用哈希表 O(1) 就可以做到

只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了

将学生名字映射到哈希表上就涉及到了 hash function，即哈希函数

哈希函数

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

哈希函数如图所示，通过 hashCode 把名字转化为数值，一般 hashcode 是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就能把学生名字映射到哈希表上的索引数字了

如果 hashCode 得到的数值大于哈希表大小，即大于 tableSize，怎么操作？

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

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

哈希碰撞

如图，小李和小王都映射到了索引小标 1 的位置，这就是哈希碰撞

一般哈希碰撞有两种解决方法，拉链法和线性探测法

拉链法

把发生冲突的元素都存储在链表中，就可以通过索引找到小李和小王了

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

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

线性探测法

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

比如冲突的位置，放了小李，就向下找一个空位放置小王的信息。所以要求 tableSize 一定要大于 dataSize，不然就没有空位了

常见的三种哈希结构

用哈希表来解决问题的时候，一般会选择如下三种数据结构

• 数组

• set（集合）

• map（映射）

set

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 会导致整棵树错乱，只能删除和增加

  • 但依然使用哈希函数来做映射，只不过底层的符号使用了红黑树来存储数据，所以使用这些数据结构来解决映射问题时，依然称之为哈希法（map 同理）

map

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
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 的底层实现是红黑树，同理 key 也是有序的（面试常考，考察对语言容器底层的理解）

如何选择

要使用集合来解决哈希问题的时候

1. 优先用 unordered_set，查询和增删效率最优

2. 如果需要集合是有序的，用 set

3. 如果要求不仅有序还要有重复数据，用 multiset

备注

unordered_set 在 C++11 时引入了标准库，hash_set 没有。优先使用官方认证的内容。

总结

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

如果面试的时候遇到需要判断一个元素是否出现过的场景，也应该第一时间想到哈希法。

242.有效的字母异位词

题目

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例：

输入: s = "anagram", t = "nagaram"
输出: true

提示：

• 1 <= s.length, t.length <= 5 * 10(4)

• s 和 t 仅包含小写字母

思路

题目中只会有小写的字母，即 a~z，ASCII 码是连续的，所以 a 可以对应到下标为 0 的位置，z 对应 25，一共 26 个字母

定义一个数组 hash[26]，能放下 26 个字母的大小

只需要用这个数组，统计第一个字符串里每一个字母出现的频率，在遍历第二个字符串时，每个字母出现的频率在数组里再做对应的减法。

如果 hash 数组里所有元素都是 0，说明两个字符串就是有效的字母异位词，符合题意

数据结构选择：

• 因为哈希值比较小，范围也比较小且可控，所以用数组就可以了

• 如果数值很大，就用 set

• 如果 k 对应 value 的话，用 map

代码实现

• 定义哈希数组，默认里面元素为 0

• 用数组统计第一个字符串 s 内出现字母的频率

  • for 循环遍历字符串
  • hash[s[i] - 'a']++; 将字符串 s 所有字母出现的频率都统计到哈希表内

• 遍历第二个字符串 t，在前一个数组的基础上做 – 操作，最后判断数组所有的元素是不是都是 0

  • for 循环遍历字符串
  • hash[t[i] - 'a']--;

• 最后对哈希数组进行判断

  • for 循环遍历 26 个字母
  • 如果遍历到的哈希数组元素不等于 0，返回 false

• return true

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. 两个数组的交集

题目

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

提示：

• 1 <= nums1.length, nums2.length <= 1000

• 0 <= nums1[i], nums2[i] <= 1000

这里默认数值非常大，没有限制

思路

把 nums1 里边所有的数值放到哈希表里，再遍历 nums2 每个元素是否在哈希表里出现过，如果出现过，再放进 result 里，result 需要去重

因为默认数组内数值非常大，没有限制，所以用 set 比较合适（但现在给了 1000 的限制，也可以用数组）

set 的选择

• set

• unordered_set

• multi_set

这里选用 unordered_set，因为直接是哈希映射。另外两个底层是树，还有一个查找的过程

代码实现

set 方法

• 定义 unordered_set 存放 result（unordered_set 自动做去重了）

• 定义哈希表 unordered_set num_set(nums1)，把 nums1 放进哈希表做初始化

• for 循环遍历 nums2，遍历过程看哈希表有没有出现过

  • if num_set.find(nums2[i]) != num_set.end()，如果找到了元素，result.insert(nums2[i])

• return vector(result)

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for(int num : nums2){
            if(nums_set.find(num) != nums_set.end()){
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

数组方法

• 定义一个稍大一点的数组，hash[1005]

• 定义一个 unordered_set 的集合 result，目的是做去重

• 遍历 nums1，有出现的数字，对应的 hash 位置置 1

• 遍历 nums2，如果对应数字位置为 1，代表是交集，都出现过

  • result.insert

• return

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

补充

unordered_set.end()，指向的是最后一个元素之后的位置

202. 快乐数

题目

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

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。

然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。

如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例：

输入：n = 19
输出：true
解释：
1(2) + 9(2) = 82
8(2) + 2(2) = 68
6(2) + 8(2) = 100
1(2) + 0(2) + 0(2) = 1

提示：

• 1 <= n <= 2(31) - 1

思路

先写一个求和函数，思路就是写一个 while，从个位开始不断求每一位的平方，然后加在一起 sum

然后判断是否为快乐数，用哈希表判断 sum 是否重复出现过，如果重复就 return

false，否则一直找到 sum = 1 为止

代码实现

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

1. 两数之和

题目

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

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

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

示例：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

提示：

• 2 <= nums.length <= 104

• -109 <= nums[i] <= 109

• -109 <= target <= 109

• 只会存在一个有效答案

思路

如图，target 为9，遍历第一个元素是 2，此时需要的是 7 来凑成相加得 9

所以可以把思路转为判断一个元素是否遍历过，把遍历过的元素加到集合里，每次遍历的时候就去判断想要寻找的元素是否在集合里出现过

集合用的就是哈希表的结构

哈希表的选择

想要找一个元素是否出现过，同时还要知道这个元素在数组里的下标，相当于要判断两个元素，一个是数组里的数值，一个是数组里的下标。

有两个元素，此时就用 map。元素是 map 的 key，下标是 map 的 value

key 和 value 的设置要思考查找的是什么，题中查找的是一个元素是否出现过，所以要把元素作为 key

map 能在最短的时间内，查找 key 是否在 map 中出现过

map 在题目中的作用，是存放遍历过的元素

map 存放过程

如上图，先遍历 2，找不到 7，在 map 中 key 存 2，value 存 0

再遍历 7，找到了 2

map 的选择

• map

• unordered_map

• multi_map

本题选择 unordered_map，因为存读效率最高。且 map 和 multi_map 的 key 是有序的（面试常考），本题不需要 key 有序。

代码实现

• 定义 unordered_map，key 和 value 都是 int unordered_map map;

• for 遍历数组 nums

  • 定义要查询的值 s，等于 target - nums[i]
  • 去 map 中查询 s
  • 如果出现过
    • 返回两数的下标，一个下标是存放的 value，另一个下标是当前遍历的元素 i
  • 如果没出现过，把遍历过的元素加入到 map 中

• return {};

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