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

【昨天第五天周末休息】

哈希表理论基础

哈希表

哈希表（Hash table，国内也有一些算法书籍翻译为散列表）

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

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

哈希函数

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

哈希碰撞

如图所示，小李和小王都映射到了索引下标 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值会导致整棵树的错乱，所以只能删除和增加。

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
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也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

红黑树（Red-Black Tree）是一种自平衡的二叉搜索树（Binary Search Tree），它通过一些规则来确保树的平衡性，以保持其高效的插入、删除和查找操作。红黑树的特点包括：

1. 节点颜色：每个节点都带有颜色属性，可以是红色或黑色。

2. 根节点：根节点是黑色的。

3. 叶子节点：叶子节点（NIL节点或空节点）被认为是黑色的。

4. 颜色规则：不能有相邻的两个红色节点，即红色节点不能连续出现。

5. 黑高度：从根节点到任何叶子节点的路径上，黑色节点的数量必须相同。这确保了树的平衡性。

由于这些规则，红黑树在树的高度上有一定的上限，因此它保证了在最坏情况下的查找、插入和删除操作的时间复杂度都是O(log n)，其中n是树中节点的数量。这使得红黑树成为一种高效的数据结构，经常用于实现各种高级数据结构和算法，例如C++的std::map和std::set。

红黑树的平衡性和性能保证使它在实际应用中非常有用，尤其在需要高效插入、删除和查找操作的情况下。但需要注意，虽然红黑树的平均性能很好，但在某些特定情况下，它可能会导致树的不平衡，因此在选择数据结构时需要根据应用的需求和特点进行权衡和选择。

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

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

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

242. 有效的字母异位词

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

视频链接：学透哈希表，数组使用有技巧！Leetcode：242.有效的字母异位词_哔哩哔哩_bilibili

文章链接：代码随想录

class Solution {
public:
    bool isAnagram(string s, string t) {
        // 数组在哈希表里的经典应用
        int hash[26] = {0};  // 注意全初始化为0
        for(int i=0; i<s.size(); i++){
            hash[s[i]-'a']++;
        }
        for(int i=0; i<t.size(); i++){
            hash[t[i]-'a']--;
        }
        for(int i=0; i<26; i++){
            if(hash[i]!=0) return false;
        }
        return true;
    }
};

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

349. 两个数组的交集

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

视频链接：学透哈希表，set使用有技巧！Leetcode：349. 两个数组的交集_哔哩哔哩_bilibili

文章链接：代码随想录

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 i=0; i<nums2.size(); i++){
            if(nums_set.find(nums2[i]) != nums_set.end()){
                result.insert(nums2[i]);
            }
        }
        return vector<int>(result.begin(), result.end());
    }
};

• 时间复杂度: O(mn)
• 空间复杂度: O(n)

202. 快乐数

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

【无视频讲解】

文章链接：代码随想录

【思路】

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！

所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

判断sum是否重复出现就可以使用unordered_set。

还有一个难点就是求和的过程，如果对取数值各个位上的单数操作不熟悉的话，做这道题也会比较艰难。

class Solution {
public:
    // 取数值各个位上的单数之和
    int getSum(int n){
        int sum = 0;
        while(n){
            sum += (n%10)*(n%10);
            n = 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;
            n = sum;
            set.insert(sum);
        }
    }
};

• 时间复杂度: O(log n)
• 空间复杂度: O(log n)

在每次迭代中都是将n除以10，将n的位数减小一个数量级（去掉最后一位数字）。这意味着需要迭代的次数与n的位数（数字的长度）有关。因此，时间复杂度与n的位数成正比，可以表示为O(log n)。

1. 两数之和

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

视频链接：梦开始的地方，Leetcode：1.两数之和，学透哈希表，map使用有技巧！_哔哩哔哩_bilibili

文章链接：代码随想录

	元素	下标
map	key	value

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）

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++){
            int s = target - nums[i];
            auto findItem = map.find(s);
            if(findItem!=map.end()){
                return {i,findItem->second};  // 注意这里value的提取方式是->second
            }
            map.insert(pair<int, int>(nums[i], i));  // 注意这里map的插入方式
        }
        return {};
    }
};

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