文章目录
前言
本文的例题都将通过python来实现,但是哈希表在python中的表示为字典形式。所以与其他语言还是有较大的冲突。在python中,其实有一个非常好用的类——defaultdict。具体用法见:
https://blog.csdn.net/yangsong95/article/details/82319675
一、242. 有效的字母异位词
题解
数组其实也是一个特殊的哈希表,而且这道题目中字符串只有小写字符,那么就可以定义一个数组,来记录字符串s里字符出现的次数。数组的长度可以定为26,初始化为0,因为a到z的ASCII也是26个连续的值。定义一个数组叫做record用来上记录字符串s里字符出现的次数。
需要把字符映射到数组也就是哈希表的索引下标上,因为字符a到字符z的ASCII是26个连续的数值,所以字符a映射为下标0,相应的字符z映射为下标25。
再遍历 字符串s的时候,只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可,并不需要记住字符a的ASCII,只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数,统计出来了。
那看一下如何检查字符串t中是否出现了这些字符,同样在遍历字符串t的时候,对t中出现的字符映射哈希表索引上的数值再做-1的操作。
那么最后检查一下,record数组如果有的元素不为零0,说明字符串s和t一定是谁多了字符或者谁少了字符,return false。
最后如果record数组所有元素都为零0,说明字符串s和t是字母异位词,return true。
代码
'''
新建一个0-25数组,在遍历s的时候,相应位置加一,遍历t的时候,相应位置减一,
如果最后数组全为0,则返回True,否则返回false
'''
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
res = [0]*26
for i in range(len(s)):
res[ord(s[i])-ord('a')] += 1 #ord()函数为python内置函数,可以求出ASCII码,此题只需要求出与a的相对距离就好了
print(res)
for j in range(len(t)):
res[ord(t[j])-ord('a')] -= 1
print(res)
for k in range(len(res)):
if res[k] != 0:
return False
break
return True
下面这个写法没有使用数组作为哈希表,使用了上文提到的defaultdict
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_dict
二、349. 两个数组的交集
题解
其实这个题目可以使用直接遍历的方式来暴力求解,但是时间复杂度太高,这里使用set来解决这个问题。
set和list其实有着本质的区别,set会去重,list不会
代码
代码很简单,因为经过set处理后,列表里的元素就没有重复的了
'''
其实这个题目可以通过遍历来实现,但是时间复杂度太高,可以用set来解决这个问题
set会去重
'''
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
return list(set(nums1) & set(nums2))
三、202. 快乐数
题解
这个题需要理解什么是快乐数,其实只要搞明白,当一个数在计算过程中重复出现某一个结果的时候,这个数就必然不是快乐数了,因为已经陷入了无限循环中,如果最后的计算结果为一,那它就是快乐数。还有一点要求,理解对一个数分解的逻辑。
代码
'''
如果一个数重复出现,则说明进入了死循环,必不是快乐数
'''
class Solution:
def isHappy(self, n: int) -> bool:
#计算过程
def cal_happy(num):
sum = 0
#从个位开始计算
while num:
sum += (num%10)**2
num = num//10
return sum
#新建一个集合存储已经出现过的数
record = set()
while True:
n = cal_happy(n)
#如果n=1,,说明是快乐数
if n == 1:
return True
#如果已经在集合中,则直接返回False
if n in record:
return False
else:
record.add(n)
四、1. 两数之和
题解
这个题目给出了一个数组,但是在返回时要求返回下标。我们可以想一下,在Python中有什么存储结构可以同时存储两种互相对应的数据呢?没错,那就是字典。我们可以让key保存数值,value保存数值所在的下标。
代码
'''
使用字典,因为我们要存储值和下标
'''
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
record = dict()
#用枚举更方便,就不需要通过索引再去取当前位置的值
for idx,val in enumerate(nums):
if target-val not in record:
record[val]=idx
else:
#如果存在就返回字典记录索引和当前索引
return [record[target-val],idx]
五、454. 四数相加 II
题解
首先先定义一个dict1,将num1和num2的和放入字典中,key为和,value为出现的次数
然后再定义一个dict2,判断num3和num4的和的相反数是否在dict2中,若存在就用count统计value
代码
'''
首先先定义一个dict1,将num1和num2的和放入字典中,key为和,value为出现的次数
然后再定义一个dict2,判断num3和num4的和的相反数是否在dict2中,若存在就用count统计value
'''
class Solution:
def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
dict1 = dict()
for i in nums1:
for j in nums2:
if i+j in dict1:
dict1[i+j] += 1
else:
dict1[i+j] = 1
count = 0
for i in nums3:
for j in nums4:
key = -(i+j)
if key in dict1:
count += dict1[key]
return count
六、383. 赎金信
题解
这道题目和242.有效的字母异位词很像,有效的字母异位词 (opens new window)相当于求字符串a 和 字符串b是否可以相互组成 ,而这道题目是求字符串a能否组成字符串b,而不用管字符串b能不能组成字符串a。
代码
'''这个题目其实和那个异位词的差不多'''
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
record = [0]*26
#首先遍历magazine,将出现的字母在与a的相对位置上加一
for i in magazine:
record[ord(i)-ord('a')] += 1
#遍历ransomNote
for i in ransomNote:
#如果没有出现过,则一定返回false
if record[ord(i)-ord('a')] == 0:
return False
else:
record[ord(i)-ord('a')] -= 1
return True
使用defaultdict
'''
这个题目其实和那个异位词的差不多,使用defaultdict()
'''
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
from collections import defaultdict
#记录每个字母出现的次数,key为字母,value为出现的次数
hashmap = defaultdict(int)
#出现一次就加一
for x in magazine:
hashmap[x] += 1
for x in ransomNote:
#获取x出现的次数
val = hashmap.get(x)
#如果ran中的字母在mag中没有出现过,或者已经被用完了,false
if val is None or val ==0:
return False
#次数减一
else:
hashmap[x] -= 1
return True
七、15. 三数之和
题解
这道题我们采取双指针的方法,首先将数组排序(在做数组相关的题目中,如果没有思路,就先对数组进行排序),然后有一层for循环,i从下标为零的地方开始遍历,left=i+1,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]]:
res = [] #返回数组
nums = sorted(nums) #先排序
for i in range(len(nums)):
if nums[i]>0:
return res
left = i+1
right = len(nums)-1
#去重
if i>0 and nums[i] == nums[i-1]:
continue
total = 0
while left < right:
total = nums[i]+nums[left]+nums[right]
if total<0:
left += 1
elif total>0:
right -= 1
else:
res.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
return res
八、18. 四数之和
题解
这个题目和三数之和没有什么区别,只是在三数之和的基础上再多加一层循环,其实就类似于三指针。
代码
class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
nums.sort()
n = len(nums)
res = []
for i in range(n):
if i > 0 and nums[i] == nums[i - 1]: continue
for k in range(i+1, n):
if k > i + 1 and nums[k] == nums[k-1]: continue
p = k + 1
q = n - 1
while p < q:
if nums[i] + nums[k] + nums[p] + nums[q] > target: q -= 1
elif nums[i] + nums[k] + nums[p] + nums[q] < target: p += 1
else:
res.append([nums[i], nums[k], nums[p], nums[q]])
while p < q and nums[p] == nums[p + 1]: p += 1
while p < q and nums[q] == nums[q - 1]: q -= 1
p += 1
q -= 1
return res