目录
哈希表
哈希表理论基础
那么哈希表能解决什么问题呢，一般哈希表都是用来快速判断一个元素是否出现集合里。
例如要查询一个名字是否在这所学校里。
要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。
242.有效的字母异位词
给定两个字符串 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:
record = [0] * 26
for i in s:
#并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
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:
#record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
return False
return Trueord()函数是Python中的一个库函数，用于获取ASCII给定字符的值 。
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
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_dictclass 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_count349. 两个数组的交集
给定两个数组，编写一个函数来计算它们的交集。
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
# 法一
return list(set(nums1)&set(nums2))
# 法二
hash_dict = {}
result = []
for i in range(len(nums1)):
hash_dict[nums1[i]] = 1
for i in range(len(nums2)):
# if hash_dict[nums2[i]] == 1: # 直接这么写会报错，需要先判断nums2[i]存在于字典中
if nums2[i] in hash_dict.keys() and hash_dict[nums2[i]] == 1:
result.append(nums2[i])
# 如何处理重复元素？
# 只需要在append第一次出现的元素之后把原字典内对应value置零即可
hash_dict[nums2[i]] = 0 # ❗这一行看答案了
return result
202. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
示例：
输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1
class Solution:
def isHappy(self, n: int) -> bool:
def getSum(n):
summary = 0
while n: # 从个位开始依次取，平方求和
summary += (n % 10) * (n % 10)
# n /= 10 # ❗ 错误
# 在Python中/表示浮点整除法，返回浮点结果，也就是结果为浮点数;
# 而//在Python中表示整数除法，返回小于结果的一个最大的整数，意思就是除法结果向下取整。
# 举例
# print("6 // 4 = " + str(6 // 4))
# print("6 / 4 =" + str(6 / 4))
# 结果：
# 6 // 4 = 1
# 6 / 4 =1.5
n = n // 10
return summary
hash_dict = {}
summary = n
while 1:
summary = getSum(summary)
if summary == 1:
return True
if summary in hash_dict.keys():
return False
else:
hash_dict[summary] = 1class Solution:
def isHappy(self, n: int) -> bool:
def calculate_happy(num):
sum_ = 0
# 从个位开始依次取，平方求和
while num:
sum_ += (num % 10) ** 2
num = num // 10
return sum_
# 记录中间结果
record = set()
while True:
n = calculate_happy(n)
if n == 1:
return True
# 如果中间结果重复出现，说明陷入死循环了，该数不是快乐数
if n in record:
return False
else:
record.add(n) #注意set()的用法
1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。
在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
hash_dict = {}
for i in range(len(nums)):
if target - nums[i] in hash_dict.keys():
return hash_dict[target-nums[i]], i
else:
hash_dict[nums[i]] = i
return 0
454.四数相加II
给定四个包含整数的数组列表 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 。
例如:
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:
2
解释:
两个元组如下:
(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
- 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
- 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
- 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
- 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
- 最后返回统计值 count 就可以了
class Solution:
def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
hash_dict = {}
count = 0
for i in range(len(nums1)):
for j in range(len(nums2)):
if nums1[i]+nums2[j] in hash_dict.keys():
hash_dict[nums1[i]+nums2[j]] += 1
else:
hash_dict[nums1[i]+nums2[j]] = 1
for i in range(len(nums3)):
for j in range(len(nums4)):
if -nums3[i]-nums4[j] in hash_dict.keys():
count += hash_dict[-nums3[i]-nums4[j]]
return count383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：
你可以假设两个字符串均只含有小写字母。
canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
hash_abc = [0] * 26
for i in range(len(magazine)):
hash_abc[ord(magazine[i]) - ord('a')] += 1
for i in range(len(ransomNote)):
if hash_abc[ord(ransomNote[i]) - ord('a')] == 0:
return False
else:
hash_abc[ord(ransomNote[i]) - ord('a')] -= 1
return True看代码随想录文章后新增知识：
之前在使用字典的时候, 用的比较随意, 只是简单的使用dict.
然而这样在使用不存在的key的时候发生KeyError这样的一个报错, 这时候就该defaultdict登场了.
from collections import defaultdict
d1 = defaultdict(int)
使用defaultdict任何未定义的key都会默认返回一个根据method_factory参数不同的默认值, 而相同情况下dict()会返回KeyError.
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
from collections import defaultdict
hashmap = defaultdict(int)
for x in magazine:
hashmap[x] += 1
for x in ransomNote:
value = hashmap.get(x) #读取dict中value #说的就是这里
if value is None or value == 0:
return False
else:
hashmap[x] -= 1
return True
另外还有counter：
有了这个函数就不用手动的使用 for 循环来手动统计词频啦！
Counter() 是 collections 库中的一个函数，可以用来统计一个 python 列表、字符串、元组等可迭代对象中每个元素出现的次数，并返回一个字典。
nums = [1, 1, 1, 6, 6, 6, 7, 8]
count = Counter(nums)
for k, v in count.items():
print(k, v)
使用 Counter 统计完词频后可以使用 most_common 方法来查找出现频率最高的 k 个数字及其出现次数。
ansdict = count.most_common(2) # 返回出现次数最多的两个数及其出现的次数 如[(1, 3), (6, 3)]
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
c1 = collections.Counter(ransomNote)
c2 = collections.Counter(magazine)
x = c1 - c2
#x只保留值大于0的符号，当c1里面的符号个数小于c2时，不会被保留
#所以x只保留下了magazine不能表达的
if(len(x)==0):
return True
else:
return False15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。
接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
nums = sorted(nums)
result = []
i = 0
left = 0
right = len(nums) - 1
for i in range(len(nums)): #这种或许用for不合适 因为可能会在循环中改i的值 更保险是用while：while i != len(nums) - 1:
if nums[i] > 0:
break # 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了 # 这两行是抄答案的
if i > 0 and nums[i] == nums[i - 1]:
continue # 注意这里不用i+=1了因为for本身自会+1
#另外，记得这个nums是从小到大排列的
else:
left = i + 1
right = len(nums) - 1
while left < right:
if nums[i] + nums[left] + nums[right] == 0:
result.append([nums[i], nums[left], nums[right]])
#出大问题。到此结束的话没有让left和right递增/减
left += 1
right -= 1
# while nums[left] == nums[left - 1]:
# #出大问题。没有规定left和right的大小关系
while left < right and nums[left] == nums[left - 1]:
left += 1
while left < right and nums[right] == nums[right + 1]:
right -= 1
elif nums[i] + nums[left] + nums[right] < 0:
left += 1
else:
right -= 1
return result 18. 四数之和
题意：给定一个包含 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 = sorted(nums)
result = []
left = 0
right = len(nums)- 1
#❗第一步先开始第一层循环，剪枝+查重后开始正式处理
for k in range(len(nums)):
if target > 0 and nums[k] > target:
# return []
break
if k > 0 and nums[k] == nums[k - 1]:
continue
#❗第二步进入第二层循环，也是剪枝+查重后再正式处理。第二层循环中，left和right分别初始化为i+1和len(nums)-1
for i in range(k + 1, len(nums)):
# if target > 0 and nums[i] + nums[k] > target:
# return []
# # 不要这样剪枝。否则如果遇到[-1, 0, 1, 2]然后target=2的话，遍历到k=2 i=3的时候，
# # 1+2>2直接返回[]了，哪怕此时result是有值的。
# # 所以应写return result
# # 更好的写法是这里break然后最后统一return
# if target > 0 and nums[i] + nums[k] > target:
# return result
# # 这里写return result依旧是不对的。因为这个二级剪枝减去的只是剩余的i可以不参与循环，
# # 但剩余的k依旧要继续参与循环。所以不能直接return。
# # 只是说可以结束该for循环回到第一级for循环。
if target > 0 and nums[i] + nums[k] > target:
break
if i > k + 1 and nums[i] == nums[i - 1]:
continue
#❗剪枝+查重后第三步是开始在left
left = i + 1
right = len(nums) - 1
while(left < right):
if nums[k]+nums[i]+nums[left]+nums[right] < target:
left += 1
elif nums[k]+nums[i]+nums[left]+nums[right] > target:
right -= 1
else:
result.append([nums[k], nums[i], nums[left], nums[right]])
#❗第四步，找到符合要求的组合后，继续往下推进，left和right分别自增自减，然后查重
left += 1
right -= 1
while left < right and nums[left] == nums[left - 1]:
left += 1
while left < right and nums[right] == nums[right + 1]:
right -= 1
return result
154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
