代码随想录day 6：哈希表 1（哈希表基础，有效的字母异位词，两个数组交集，快乐数，两数之和）

1.哈希表基础

哈希表（hash table，散列表）是是一种根据关键码值（Key value）而直接进行访问的数据结构。它通过将关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数被称为散列函数（哈希函数），存放记录的数组被称为散列表。给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希（Hash）表，函数f(key)为哈希（Hash）函数。（这边简单理解为一个函数，将一个域的input投射到另一个域的output，输入input得到output，故查询的速度为O(1))

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

举例： 例如要查询一个名字是否在这所学校里。要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。

我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。将学生姓名映射到哈希表上就涉及到了hash function ，也就是哈希函数。

• 哈希函数

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

（图源：代码随想录）

如果hashCode得到的数值大于 哈希表的大小了，也就是大于tableSize了，怎么办呢？

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

• 哈希碰撞

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

如图所示，小李和小王都映射到了索引下标 1 的位置，这一现象叫做哈希碰撞。

以下两种方式可以用来解决哈希碰撞

1. 拉链法（链表套数组）

刚刚小李和小王在索引1的位置发生了冲突，发生冲突的元素都被存储在链表中。 这样我们就可以通过索引找到小李和小王了

数据规模为dataSize，哈希表大小为hashSize。

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

2. 线性探测法 （大表硬塞）

保证table size大于data size，用哈希表中的空位来防止碰撞，缺点是比较浪费空间。

例如冲突的位置，放了小李，那么就向下找一个空位放置小王的信息。所以要求tableSize一定要大于dataSize ，要不然哈希表上就没有空置的位置来存放 冲突的数据了。如图所示：

• 常见的几种哈希结构

list，set，map （数组，集合，映射）。

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

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

要注意python中不能直接使用multi和unordered这些数据结构。

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

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

总结：

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

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

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

2. 有效的字母异位词（leetcode 242）

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        #我们尝试用数组的写法
        record = [0] * 26    #设置tablesize为26，够用
        for i in s:    #通过每个字符的ASCII来录入我们的record表
            record[ord(i) - ord('a')] += 1
        for i in t:
            record[ord(i) - ord('a')] -= 1
        return set(record) == set([0])

这题也是非常的直观，我们用ASCII作为我们的hash function来把每个字符的出现频率记录进我们的hash table record数组里面。

这题我们也能用dictionary来记录频率，好处是能更高效的使用空间，坏处是我们每次查询字母是否在dictionary中都要遍历一次dictionary，时间复杂度更高。数组写法是比较经典的用空间换时间的写法。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        sdic = defaultdict(int)
        tdic = defaultdict(int)
        for i in s:
            sdic[i] += 1
        for i in t:
            tdic[i] += 1
        return sdic == tdic

还有我们的计数器写法，比较方便快捷：

class Solution(object):
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import Counter
        a_count = Counter(s)
        b_count = Counter(t)
        return a_count == b_count

3. 两个数组的交集（leetcode 349）

使用数组来做哈希的题目，是因为题目都限制了数值的大小。

而这道题目没有限制数值的大小，就无法使用数组来做哈希表了。

而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

暴力解法：

O(n^2)，但是省空间

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        inter = []
        for i in nums1:
            if i in nums2:
                inter += [i]
        return list(set(inter))

set法：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

这题由于没有限制数值大小，直接使用set比较节省空间。

但是直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。

不要小瞧 这个耗时，在数据量大的情况，差距是很明显的。

dictionary 法：

这是我想到的最好的办法，使用的dictionary，只记录了有出现过的数字，节省了空间，同时又只遍历了两组nums一次（dictionary查询为O(1)），时间复杂度仅为O(n)。

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        record = dict()
        for i in nums1:
            record[i] = 1
        for i in nums2:
            if i in record:
                record[i] = 2
        return [i for i in record if record[i] == 2]

4. 快乐数（leetcode 202）

这道题的解题关键点在于数字在digit做square sums的过程中，很可能会重复数字。如果重复出现的话，证明陷入循环，return false。理解思路后代码的实现就很直观了：

class Solution:
    def isHappy(self, n: int) -> bool:
        record = set()
        while n != 1:
            n = str(n)          
            n = sum([int(i)** 2 for i in n])
            print(n)
            if n in record:
                return False
            else:
                record.add(n)

        return True

5. 两数之和（leetcode 1）

本题其实有四个重点：

• 为什么会想到用哈希表
• 哈希表为什么用dict
• 本题dict是用来存什么的
• dict中的key和value用来存什么的

1. 当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。

2. 因为本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用dict正合适。我们用dict来存放已经遍历过的元素，然后在遍历的过程中查询我们想要的元素是否在dict中，如果存在，直接return。

这题总体来说还是比较基础的题，主要考察的是你对哈希表的灵活运用程度和意识，下面我们看看代码如何实现：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        record = dict()

        for i ,values in enumerate(nums):
            if target - values not in record:
                record[values] = i
            else:
                return [i, record[target-values]]