【leetcode刷题版】哈希表
系列文章目录
文章目录
- 系列文章目录
- 背景知识
- 一、有效的字母异位词
- 二、两个数组的交集
- 三、快乐数
- 四、两数之和
- 五、四数相加
- 六、赎金信
- 七、三数之和
- 八、四数之和
背景知识
- 哈希函数（Hash Function）：
哈希函数是一种将任意长度的输入（键）通过某种算法转换为固定长度的输出（哈希值）的函数。
好的哈希函数应该能够将输入均匀地分布在哈希表中，以减少冲突。 - 冲突（Collision）：
当两个不同的键通过哈希函数得到相同的哈希值时，就会发生冲突。
解决冲突的常见方法包括链地址法（Chaining）、开放寻址法（Open Addressing）和双重哈希（Double Hashing）。 - 链地址法（Chaining）：
每个哈希表的槽位（Slot）存储一个链表。
当发生冲突时，新的元素会被添加到链表的末尾。 - 开放寻址法（Open Addressing）：
当发生冲突时，算法会在哈希表中寻找下一个空闲的槽位。
常见的探测方法包括线性探测、二次探测和双重散列。 - 动态扩容（Dynamic Resizing）：
当哈希表中的元素太多，导致冲突增加时，性能会下降。这时可能需要对哈希表进行扩容。
扩容通常涉及到创建一个新的更大的哈希表，并将旧表中的所有元素重新哈希到新表中。 - 负载因子（Load Factor）：
负载因子是哈希表中已使用的槽位数与总槽位数的比率。
负载因子越高，冲突的可能性越大，因此通常需要在负载因子超过某个阈值时进行扩容。 - 时间复杂度：
在理想情况下（即没有冲突），哈希表的插入、删除和查找操作的时间复杂度为 O(1)。
在最坏情况下（即所有元素都冲突），这些操作的时间复杂度为 O(n)，其中 n 是哈希表中元素的数量。 - 哈希表的应用：
哈希表广泛应用于数据库、缓存实现、密码学、唯一性检查等领域。 - 哈希表的实现：
在许多编程语言中，哈希表通过字典（如 Python 中的dict）、哈希映射（如 Java 中的HashMap）或对象（如 JavaScript 中的对象）实现。 - 安全性问题：
在某些情况下，哈希函数可能会受到哈希碰撞攻击，攻击者可能会尝试找到两个不同的输入，它们产生相同的哈希值。
如果在做面试题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！
class HashTable:
def __init__(self, size=10):
self.size = size
self.table = [[] for _ in range(self.size)]
def hash(self, key):
return hash(key) % self.size
def insert(self, key, value):
index = self.hash(key)
for i, (k, v) in enumerate(self.table[index]):
if k == key:
self.table[index][i] = (k, value)
return
self.table[index].append((key, value))
def get(self, key):
index = self.hash(key)
for k, v in self.table[index]:
if k == key:
return v
return None
def delete(self, key):
index = self.hash(key)
for i, (k, v) in enumerate(self.table[index]):
if k == key:
del self.table[index][i]
return True
return False
一、有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。 示例 1: 输入: s = "anagram", t = "nagaram" 输出: true 示例 2: 输入: s = "rat", t = "car" 输出: false 说明: 你可以假设字符串只包含小写字母。
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
# 如果长度不同，直接返回 False
if len(s) != len(t):
return False
# 对两个字符串进行排序
return sorted(s) == sorted(t)
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
# 如果长度不同，直接返回 False
if len(s) != len(t):
return False
# 创建一个大小为 26 的数组，用于记录每个字符的出现次数
count = [0] * 26
# 遍历字符串 s，增加对应字符的计数
for char in s:
count[ord(char) - ord('a')] += 1
# 遍历字符串 t，减少对应字符的计数
for char in t:
count[ord(char) - ord('a')] -= 1
if count[ord(char) - ord('a')] < 0:
return False # 如果某个字符的计数小于 0，说明 t 中的字符比 s 多
return True
二、两个数组的交集
题意：给定两个数组，编写一个函数来计算它们的交集。
#方法一
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
return list(set(nums1)&set(nums2))
#方法二
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
# 使用哈希表记录第一个数组中的元素
hash_table = {}
for num in nums1:
hash_table[num] = True
# 遍历第二个数组，检查每个元素是否在哈希表中
result = []
for num in nums2:
if num in hash_table:
result.append(num)
del hash_table[num] # 避免重复
return result
三、快乐数
编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。 如果 n 是快乐数就返回 True ；不是，则返回 False 。
class Solution:
def isHappy(self, n: int) -> bool:
def get_next(number):
"""计算下一个数字，即每个位置上的数字的平方和"""
total_sum = 0
while number > 0:
digit = number % 10 # 获取当前数字的最后一位
total_sum += digit * digit # 累加平方和
number //= 10 # 去掉最后一位
return total_sum
seen = set() # 用于记录已经出现过的数字
while n != 1 and n not in seen:
seen.add(n) # 将当前数字加入集合
n = get_next(n) # 计算下一个数字
return n == 1 # 如果最终变为1，则是快乐数
四、两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
from typing import List
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
# 创建一个哈希表，用于存储数组元素及其对应的索引
hash_map = {}
# 遍历数组
for i, num in enumerate(nums):
# 计算当前元素的补数（即目标值减去当前元素）
complement = target - num
# 检查补数是否已经在哈希表中
if complement in hash_map:
# 如果找到了，返回补数的索引和当前元素的索引
return [hash_map[complement], i]
# 如果没有找到，将当前元素及其索引存入哈希表
hash_map[num] = i
# 如果没有找到答案，返回空列表（根据题意，这种情况不会发生）
return []
五、四数相加
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。 为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。
class Solution:
def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
hashmap = dict()
for n1 in nums1:
for n2 in nums2:
if n1+n2 in hashmap:
hashmap[n1+n2] += 1
else:
hashmap[n1+n2] = 1
count = 0
for n3 in nums3:
for n4 in nums4:
key = -n3-n4
if key in hashmap:
count += hashmap[key]
return count
#使用Counter包
from typing import List
from collections import Counter
class Solution:
def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
# 计算 A 和 B 的所有可能和
sum_ab = Counter(a + b for a in nums1 for b in nums2)
# 计算 C 和 D 的所有可能和
sum_cd = Counter(c + d for c in nums3 for d in nums4)
# 统计 A[i] + B[j] + C[k] + D[l] = 0 的元组数量
count = 0
for sum_ab_val, count_ab in sum_ab.items():
sum_cd_val = -sum_ab_val
if sum_cd_val in sum_cd:
count += count_ab * sum_cd[sum_cd_val]
return count
六、赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。 (题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
for char in ransomNote:
if char in magazine and ransomNote.count(char)<=magazine.count(char):
continue
else:
return False
return True
from collections import Counter
def can_construct_ransom(ransom, magazine):
# 统计 ransom 和 magazine 中每个字符的出现次数
ransom_count = Counter(ransom)
magazine_count = Counter(magazine)
# 检查 ransom 中的每个字符是否都能在 magazine 中找到足够的数量
for char, count in ransom_count.items():
if magazine_count[char] < count:
return False
return True
七、三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
from typing import List
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
# 首先对数组进行排序
nums.sort()
# 用于存储结果的列表
result = []
# 数组长度
n = len(nums)
# 遍历数组，对于每个元素，尝试找到两个数，使得与当前元素的和为0
for i in range(n):
# 如果当前元素已经大于0，则后面的元素都会更大，不可能找到和为0的三元组
if nums[i] > 0:
break
# 跳过重复的元素，以避免重复的三元组
if i > 0 and nums[i] == nums[i - 1]:
continue
# 使用哈希表存储剩余元素的两数之和
hashmap = {}
# 左右指针
left, right = i + 1, n - 1
while left < right:
total = nums[i] + nums[left] + nums[right]
# 如果总和为0，找到一个三元组
if total == 0:
result.append([nums[i], nums[left], nums[right]])
# 跳过重复的元素
while left < right and nums[left] == nums[left + 1]:
left += 1
while left < right and nums[right] == nums[right - 1]:
right -= 1
left += 1
right -= 1
# 如果总和小于0，移动左指针以增加总和
elif total < 0:
left += 1
# 如果总和大于0，移动右指针以减少总和
else:
right -= 1
return result
八、四数之和
题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
nums.sort()
n = len(nums)
result = []
for i in range(n):
if nums[i] > target and nums[i] > 0 and target > 0:# 剪枝（可省）
break
if i > 0 and nums[i] == nums[i-1]:# 去重
continue
for j in range(i+1, n):
if nums[i] + nums[j] > target and target > 0: #剪枝（可省）
break
if j > i+1 and nums[j] == nums[j-1]: # 去重
continue
left, right = j+1, n-1
while left < right:
s = nums[i] + nums[j] + nums[left] + nums[right]
if s == target:
result.append([nums[i], nums[j], nums[left], nums[right]])
while left < right and nums[left] == nums[left+1]:
left += 1
while left < right and nums[right] == nums[right-1]:
right -= 1
left += 1
right -= 1
elif s < target:
left += 1
else:
right -= 1
return result
参考文章：https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E6%80%BB%E7%BB%93.html#%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80