哈希表
1. 理论基础
哈希表概念:也称为散列表,是一种数据结构,它提供了快速的数据插入和查找功能。哈希表以 键值对(key-value pairs) 的方式存储数据。键是哈希表中用于唯一标识数据的元素。在很多情况下,键可以看作是数据的“名字”或“标签”。值是与键相关联的数据。在哈希表中,每个键都对应一个值,这个值可以是任何数据类型,比如数字、字符串、对象等。
- 在构造上,哈希表通过特定的哈希函数,将输入(键)转换为一个索引值(通常为整数),确定数据在表中的位置。键必须是唯一的,这意味着在同一个哈希表中,两个键值对不能有相同的键。值不是唯一的,不同的键可以对应相同的值,但每个键必须对应一个唯一的值。
- 不同键经过哈希函数计算得到相同的索引值,这成为“哈希冲突”,常用解决方法包括链地址法(Chaining)、开放地址法(Open Addressing)、双重哈希法(Double Hashing)
- 应用上,哈希表适用于快速判断一个元素是否出现在集合里。牺牲了空间换区时间,因为需要额外的数组,set或者map来存放数据,才能实现快速查找。
哈希碰撞解决方法一: 拉链法
哈希碰撞解决方法二: 线性探测法
常见的哈希结构:数组、集合、映射
2. 相关题目
有效的字母异位词
题目描述: 给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。注意:若 s 和 t 中每个字符出现的次数都相同,则称 s 和 t 互为字母异位词。
思路: 题目限制了数值的大小,采用数组来构造一个哈希表。用一个数组来判断字符串s中字母出现的频次,然后再逆向统计字符串t中字母出现的频次,若最后得到0数组,则表明所有字母出现的频次相同。注意,两个字符串应该要是等长的。这种方法实际上就是哈希表的一个简单应用,其中数组充当哈希表,数组的索引是哈希值,而数组中的计数则表示特定键(在这个例子中是字母)出现的次数
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
if len(s) != len(t):
return False
record = [0]*26
for i in s: # 字符串也可以这么表示
record[ord(i)-ord('a')] += 1 # [ord(i)-ord('a')]对应的是字母i的相对ASCII值,将其作为字母i的索引
for i in t:
record[ord(i)-ord('a')] -= 1
for i in range(len(record)):
if record[i] != 0:
return False
return True
349. 两个数组的交集
**题目描述:**给定两个数组 nums1 和 nums2 ,返回 它们的 交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
**思路:**题目中没有限制数值的大小,所以最好采用集合/字典而不是数组来构造哈希表,同时注意要求给出去重后的结果。在python中,内置函数set很容易给出去重后的结果。
方法一:集合法
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
set1 = set(nums1) # 将nums1转换为集合
set2 = set(nums2) # 将nums2转换为集合
# 使用&运算符求两个集合的交集
intersection_set = set1 & set2
# 将交集集合转换回列表并返回
return list(intersection_set)
方法二:自构造集合与字典法
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
# 创建一个字典来存储数组中所有的元素,采用nums1中的元素作为键,每个键对应的值是该元素在nums1中出现的次数
dict = {}
for i in nums1:
dict[i] = dict.get(i,0) + 1 # 使用table.get(num, 0)获取num在dict中的当前计数(如果num不在dict中,则默认为0),然后将计数加1
res = set() # 用一个集合来存储结果,如果采用字典,后续不能直接用list(dict)转换为列表
for i in nums2:
if i in dict:
res.add(i) # 如果nums2中的数字i同样出现在dict中,则将该数字加到集合res中,然后将该数字在dict中删除
del dict[i]
return list(res)
202题. 快乐数
题目描述: 编写一个算法来判断一个数 n 是不是快乐数。「快乐数」 定义为:
- 对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和。
- 然后重复这个过程直到这个数变为 1,也可能是 无限循环 但始终变不到 1。
- 如果这个过程 结果为 1,那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ;不是,则返回 false 。
思路: 可能存在无限循环的情况,即sum会重复出现,所以可以采用集合记录出现过的sum。如果这个数字变成1后,以后重复求和过程仍然会为1,不会再跳出来。说明出现1之前,sum集合里不会有1(除非这个数就为1)。
class Solution:
def isHappy(self, n: int) -> bool:
record = set()
while n not in record:
record.add(n)
new_num = 0
n_str = str(n) # 想要逐位相加,先转换为str,每位求和后再转换为int
for i in n_str:
new_num += int(i)**2
if new_num == 1:
return True
else: # 要记得将new_num转换为n,便于循环进行下去
n = new_num
return False # 已经出现循环了,且不是1
1. 两数之和
题目描述: 给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
思路: 如果用暴力解法复杂度为O(n²)。可以尝试对数组中的一个数i,找到target-i,看是否存在于数组之中,而为了减小搜索的复杂度,采用哈希表来构造搜索表。由于输入的数组包含两个信息量,数组的位置(索引)以及对应的数组值),我们采用字典来存储数组中的信息。其中,将元素值作为键,其好处是,当我们需要查找是否存在某个特定值(例如 target - value)时,我们可以直接通过键来快速访问其索引,这利用了哈希表的快速查找特性。如果使用索引作为键,即 records[index] = value,那么字典的键将是元素的索引,值是元素本身。这样做使得想要查找某个数是否存在,需要遍历records字典来找到匹配的值,将失去使用字典作为哈希表的优势。
问题: 如果让数组值作为字典的键,如果数组中存在重复元素,键不就重复了?
解答: 在Python字典中,键必须是唯一的,如果尝试用一个已经存在的键来存储值,原来的值会被新的值覆盖。这意味着,如果数组中有重复元素,字典将只会保留最后出现的元素及其索引。但依照题意,这里不用考虑这种情况。
注意: 在哈希表中查找一个元素的平均时间复杂度是O(1)。
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
record = dict()
for index, value in enumerate(nums):
if (target-value) in record: # 某个键是否存在于record之中,而record的值是需要通过键查询的
return [record[target-value],index]
else:
record[value] = index
return None
454题.四数相加II
题目描述: 给你四个整数数组 nums1、nums2、nums3 和 nums4 ,数组长度都是 n ,请你计算有多少个元组 (i, j, k, l) 能满足:
- 0 <= i, j, k, l < n
- nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
思路: 将四个数组两两分为两组,
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
# 如果 -(nums3+nums4) 存在于hashmap,则满足四数相加为0
count = 0
for n3 in nums3:
for n4 in nums4:
key = -n3-n4
if key in hashmap:
count += hashmap[key] # 统计满足条件的元组,
return count
383. 赎金信
题目描述: 给你两个字符串:ransomNote 和 magazine ,判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以,返回 true ;否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。
思路: 可以用暴力解法,双层遍历(先magazine再ransomnote),对于ransomnote中的第j个字符与magazine中第i个字符相等,则在ransomnote中删除该字符,最后判断ransomnote是否为空。或者采用哈希解法,题目中致设计小写字母,可以用数组构造哈希表,用空间换时间,创建字典dict统计magazine中每个字符出现的次数,再遍历ransomnote中字符,在dict中减去相应字符的数量,如果遍历完没有出现“ransomnote”中有新字符,或者dict中对应字符数量为<0,则返回true。
相关题目: 242.有效的字母异位词
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
# 创建一个字典来存储 magazine 中每个字符的计数
magazine_count = {}
# 遍历 magazine 字符串,统计每个字符出现的次数
for c in magazine:
if c in magazine_count:
magazine_count[c] += 1
else:
magazine_count[c] = 1
# 遍历 ransomNote 字符串
for c in ransomNote:
# 如果字符不在 magazine 的计数字典中,或者计数为0,返回 False
if c not in magazine_count or magazine_count[c] == 0:
return False
# 否则,将该字符在 magazine 中的计数减1
magazine_count[c] -= 1
# 如果所有字符都找到了,返回 True
return True
15题. 三数之和
题目描述: 给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。答案中不可以包含重复的三元组。
思路1:哈希表法 首先这和二数之和、四数之和比较,分析能否用哈希表解决?思路为用两层for循环确定(a+b)的所有取值,利用哈希表寻找 -(a+b) 是否存在于数组中,但这会引入题目所不允许的重复的三元组,需要去重。
思路2:双指针法 本题采用双指针法复杂度更低【为什么?】,先对数组进行排序 【排序是进行双指针法的基础】 。然后从索引0遍历数组中的元素,记为i,a=nums[i],再创建一个左指针left=i+1,b=nums[left],右指针right=len(nums)-1,c=nums[right],然后根据nums[i] + nums[left] + nums[right] 与 0 的大小关系决定往哪移动。
去重:① 对元素a去重,判断是否 num[i] == num[i-1]。这里不选择判断是否 num[i]+1 == num[i],是因为这样容易错过类似{-1,-1,2}的数组。②对b,c元素去重,在 a+b+c == 0 的情况下,分别判断b,c与相邻元素是否一致。
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
result = []
nums.sort() # 数组先排序
# 开始遍历
for i in range(len(nums)):
# 如果第一个元素已经>0,不需要进一步检查
if nums[0]>0:
return result
# 第一个元素开始去重
if i > 0 and nums[i] == nums[i-1]:
continue
left = i+1
right = len(nums)-1
while right > left:
sum1 = nums[i] + nums[left] + nums[right]
if sum1 < 0:
left += 1
elif sum1 > 0:
right -= 1
else:
result.append([nums[i],nums[left],nums[right]])
# 去重,在满足a+b+c==0的情况下对bc进行去重,才有意义
while right > left and nums[right] == nums[right - 1]:
right -= 1
while right > left and nums[left] == nums[left + 1]:
left += 1
# 做完一轮判断后,指针移动
left += 1
right -= 1
return result
18题. 四数之和
题目描述: 给你一个由 n 个整数组成的数组 nums ,和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] (若两个四元组元素一一对应,则认为两个四元组重复):
- 0 <= a, b, c, d < n
- a、b、c 和 d 互不相同
- nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
思路: 与三数之和的思路很类似,在此基础上再套一层for循环。和前面的四数之和不一样,前面是四个独立的数组,但本题设计一个数组。
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:
break
# 对第一个元素a去重
if i > 0 and nums[i] == nums[i-1]:
continue
for j in range(i+1,n):
if nums[i]+nums[j] > target :
break
if j > i+1 and nums[j] == nums[j-1]: # 对j去重
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