代码随想录算法训练营第六天 | 哈希表part01
哈希表理论基础
哈希表
首先什么是哈希表，哈希表（英文名字为Hash table，国内也有一些算法书籍翻译为散列表，大家看到这两个名称知道都是指hash table就可以了）。
哈希表是根据关键码的值而直接进行访问的数据结构。
这么官方的解释可能有点懵，其实直白来讲其实数组就是一张哈希表。
哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素，如下图所示：
那么哈希表能解决什么问题呢，一般哈希表都是用来快速判断一个元素是否出现集合里。
例如要查询一个名字是否在这所学校里。
要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。
我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。
将学生姓名映射到哈希表上就涉及到了hash function ，也就是哈希函数。
哈希函数
哈希函数，把学生的姓名直接映射为哈希表上的索引，然后就可以通过查询索引下标快速知道这位同学是否在这所学校里了。
哈希函数如下图所示，通过hashCode把名字转化为数值，一般hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就把学生名字映射为哈希表上的索引数字了。
如果hashCode得到的数值大于 哈希表的大小了，也就是大于tableSize了，怎么办呢？
此时为了保证映射出来的索引数值都落在哈希表上，我们会在再次对数值做一个取模的操作，这样我们就保证了学生姓名一定可以映射到哈希表上了。
此时问题又来了，哈希表我们刚刚说过，就是一个数组。
如果学生的数量大于哈希表的大小怎么办，此时就算哈希函数计算的再均匀，也避免不了会有几位学生的名字同时映射到哈希表 同一个索引下标的位置。
接下来哈希碰撞登场
哈希碰撞
如图所示，小李和小王都映射到了索引下标 1 的位置，这一现象叫做哈希碰撞。
一般哈希碰撞有两种解决方法， 拉链法和线性探测法。
拉链法
刚刚小李和小王在索引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也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。
当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。
那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。
其他语言例如：java里的HashMap ，TreeMap 都是一样的原理。可以灵活贯通。
虽然std::set和std::multiset 的底层实现基于红黑树而非哈希表，它们通过红黑树来索引和存储数据。不过给我们的使用方式，还是哈希法的使用方式，即依靠键（key）来访问值（value）。所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。std::map也是一样的道理。
这里在说一下，一些C++的经典书籍上 例如STL源码剖析，说到了hash_set hash_map，这个与unordered_set，unordered_map又有什么关系呢？
实际上功能都是一样一样的， 但是unordered_set在C++11的时候被引入标准库了，而hash_set并没有，所以建议还是使用unordered_set比较好，这就好比一个是官方认证的，hash_set，hash_map 是C++11标准之前民间高手自发造的轮子。
总结
总结一下，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。
但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。
如果在做面试题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！
242 有效的字母异位词
方法1：字典计数法
sd = {}
td = {}
for i in s:
sd[i] = sd.get(i,0) + 1
for i in t:
td[i] = td.get(i,0) + 1
return sd == td
方法2：哈希表
说白了就是一个数组用来存放索引。
record = [0] * 26
for i in s:
record[ord(i) - ord('a')] += 1
for i in t:
record[ord(i) - ord('a')] -= 1
for i in range(26):
if record[i] != 0:
return False
return True
方法3：defaultdict解题
使用了 defaultdict(int)，这是一个特殊的字典类，默认值为 int 类型，即默认值为 0。这样可以直接进行累加，而不需要手动检查键是否存在。
from collections import defaultdict
s_dict = defaultdict(int)
t_dict = defaultdict(int)
for x in s:
s_dict[x] += 1
for x in t:
t_dict[x] += 1
return s_dict == t_dict
方法4：Counter解题
若只关心频率统计，Counter 是最佳选择。对于简单的元素计数，Counter 更加简洁且通常是性能最优的。
from collections import Counter
a_count = Counter(s)
b_count = Counter(t)
return a_count == b_count
349 两个数组的交集
方法1：字典和集合
dic1 = {}
for i in nums1:
dic1[i] = dic1.get(i,0) + 1
# 使用集合存储结果
res = set()
for num in nums2:
if num in dic1:
res.add(num)
del dic1[num]
return list(res)
方法2：数组
count1 = [0] * 1001
count2 = [0] * 1001
result = []
for i in range(len(nums1)):
count1[nums1[i]] += 1
for i in range(len(nums2)):
count2[nums2[i]] += 1
for k in range(1001):
if count1[k] * count2[k] > 0 :
result.append(k)
return result
方法3：集合
return list(set(nums1) & set(nums2))
- 将
nums1和nums2转换为集合（set(nums1)和set(nums2)）。集合是无重复元素的，因此这一步去除了数组中的重复元素。 - 使用集合的交集操作（
&）来得到两个集合的公共元素。 - 将交集结果转换为列表并返回。
202 快乐数
方法1：集合
def isHappy(self, n: int) -> bool:
# 用于记录已经出现过的数值，防止陷入死循环
record = set()
# 循环计算每次n的平方和，直到n为1或者出现重复的数字
while True:
# 计算n的平方和
n = self.get_sum(n)
# 如果n等于1，说明n是一个快乐数，返回True
if n == 1:
return True
# 如果n已经出现过，说明陷入死循环，返回False
if n in record:
return False
else:
# 将当前的n添加到记录中
record.add(n)
def get_sum(self, n: int) -> int:
# 初始化新数值
new_num = 0
# 计算n的每一位数字的平方和
while n:
# divmod返回商和余数，r为当前数字的最后一位
n, r = divmod(n, 10)
# 将当前位的平方加到new_num上
new_num += r ** 2
# 返回计算结果
return new_num
def isHappy(self, n: int) -> bool:
# 用于记录已经出现过的数字，防止陷入死循环
record = set()
# 只要n没有重复出现，就继续循环
while n not in record:
# 将当前数字n添加到记录中
record.add(n)
# 计算当前数字n的各位数字的平方和
new_num = 0
n_str = str(n) # 将n转为字符串，逐位处理
for i in n_str:
new_num += int(i) ** 2 # 计算每一位数字的平方并累加
# 如果新计算的平方和为1，说明n是快乐数，返回True
if new_num == 1:
return True
else:
# 否则，将n更新为新计算的平方和
n = new_num
# 如果进入循环并且n重复出现，说明陷入了死循环，返回False
return False
方法2：数组
def isHappy(self, n: int) -> bool:
# 用于记录已经出现过的数字，防止陷入死循环
record = [] # 使用列表代替集合，记录每次出现的n
# 当n没有重复出现时，持续进行循环
while n not in record:
# 将当前数字n添加到记录中
record.append(n)
# 计算当前数字n的各位数字的平方和
new_num = 0
n_str = str(n) # 将n转换为字符串，便于逐位处理
for i in n_str:
new_num += int(i) ** 2 # 计算当前位数字的平方并累加
# 如果新计算的平方和为1，说明n是快乐数，返回True
if new_num == 1:
return True
else:
# 否则，将n更新为新计算的平方和，继续循环
n = new_num
# 如果n重复出现，说明陷入了死循环，返回False
return False
方法3：快慢指针
def isHappy(self, n: int) -> bool:
# 定义慢指针和快指针，初始化都为n
slow = n
fast = n
# 使用快慢指针法，判断是否陷入循环
while self.get_sum(fast) != 1 and self.get_sum(self.get_sum(fast)):
# 慢指针每次前进一步，计算n的平方和
slow = self.get_sum(slow)
# 快指针每次前进两步，计算n的平方和两次
fast = self.get_sum(self.get_sum(fast))
# 如果快慢指针相遇，说明陷入了循环，返回False
if slow == fast:
return False
# 如果fast的平方和为1，说明是快乐数，返回True
return True
def get_sum(self, n: int) -> int:
# 计算数字n的每一位数字的平方和
new_num = 0
while n:
# divmod函数返回商和余数，r为当前数字的最后一位
n, r = divmod(n, 10)
# 将当前位的平方加到new_num上
new_num += r ** 2
# 返回计算得到的平方和
return new_num
方法4：精简集合
def isHappy(self, n: int) -> bool:
# 使用一个集合来记录已经出现过的数字，防止陷入死循环
seen = set()
# 不断计算n的平方和，直到n等于1或者进入循环
while n != 1:
# 计算当前数字n的各位数字的平方和
n = sum(int(i) ** 2 for i in str(n))
# 如果n已经出现在集合中，说明陷入了死循环，返回False
if n in seen:
return False
# 将当前的n添加到集合中
seen.add(n)
# 如果n最终等于1，说明n是一个快乐数，返回True
return True
方法5：精简数组
def isHappy(self, n: int) -> bool:
# 使用一个列表来记录已经出现过的数字，防止陷入死循环
seen = []
# 不断计算n的平方和，直到n等于1或者进入循环
while n != 1:
# 计算当前数字n的各位数字的平方和
n = sum(int(i) ** 2 for i in str(n))
# 如果n已经出现在列表中，说明陷入了死循环，返回False
if n in seen:
return False
# 将当前的n添加到列表中
seen.append(n)
# 如果n最终等于1，说明n是一个快乐数，返回True
return True
1 两数之和
方法1：字典
思路很简单，使用字典来进行键值对的存储。
键：对应元素
值：对应索引
如果target - 键存在于字典中，那么就返回对应的值(也就是索引)
如果不存在就加到字典中
records = dict()
for index, value in enumerate(nums):
if target - value in records: # 遍历当前元素，并在map中寻找是否有匹配的key
return [records[target- value], index]
records[value] = index # 如果没找到匹配对，就把访问过的元素和下标加入到map中
return []
方法2：暴力法
for i in range(len(nums)):
for j in range(i+1, len(nums)):
if nums[i] + nums[j] == target:
return [i,j]
