精选Top面试题（3）
204计算质数（python）
#埃拉托斯特尼筛法
class Solution(object):
def countPrimes(self, n):
if n < 2:
return 0
isPrime = [1] * n
isPrime[0] = isPrime[1] = 0 # 0和1不是质数，先排除掉
# 埃式筛，把不大于根号n的所有质数的倍数剔除
for i in range(2, int(n ** 0.5) + 1):
if isPrime[i]:
isPrime[i * i:n:i] = [0] * ((n - 1 - i * i) // i + 1)
return sum(isPrime)
207-课程表（python）
#深度优先
class Solution(object):
def canFinish(self,numCourses,prerequisites):
from collections import defaultdict
graph = defaultdict(list)
# 记录
visited = set()
# 建图
for x, y in prerequisites:
graph[y].append(x)
# 深度遍历
def dfs(i, being_visited):
if i in being_visited: return False
if i in visited: return True
visited.add(i)
being_visited.add(i)
for j in graph[i]:
if not dfs(j, being_visited): return False
being_visited.remove(i)
return True
# 检测每门功课起始是否存在环
for i in range(numCourses):
# 已经访问过
if i in visited: continue
if not dfs(i, set()): return False
return True
208-前缀树（python）
#字典按字母迭代
class Trie:
def __init__(self):
self.lookup = {}
def insert(self, word: str) -> None:
tree = self.lookup
for a in word:
if a not in tree:
tree[a] = {}
tree = tree[a]
# 单词结束标志
tree["#"] = "#"
def search(self, word: str) -> bool:
tree = self.lookup
for a in word:
if a not in tree:
return False
tree = tree[a]
if "#" in tree:
return True
return False
def startsWith(self, prefix: str) -> bool:
tree = self.lookup
for a in prefix:
if a not in tree:
return False
tree = tree[a]
return True
210-课程表2（python）
class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
from collections import defaultdict
graph = defaultdict(list)
for x, y in prerequisites:
graph[y].append(x)
res = []
visited = set()
def dfs(i, being_visited):
if i in being_visited:
return False
if i in visited:
return True
visited.add(i)
being_visited.add(i)
for j in graph[i]:
if not dfs(j, being_visited):
return False
being_visited.remove(i)
res.append(i)
return True
for i in range(numCourses):
if not dfs(i, set()):
return []
return res[::-1]
130-被围绕的区域（python）
#分治
class Solution(object):
def getSkyline(self, buildings):
if not buildings: return []
if len(buildings) == 1:
return [[buildings[0][0], buildings[0][2]], [buildings[0][1], 0]]
mid = len(buildings) // 2
left = self.getSkyline(buildings[:mid])
right = self.getSkyline(buildings[mid:])
return self.merge(left, right)
# 两个合并
def merge(self, left, right):
# 记录目前左右建筑物的高度
lheight = rheight = 0
# 位置
l = r = 0
# 输出结果
res = []
while l < len(left) and r < len(right):
if left[l][0] < right[r][0]:
# current point
cp = [left[l][0], max(left[l][1], rheight)]
lheight = left[l][1]
l += 1
elif left[l][0] > right[r][0]:
cp = [right[r][0], max(right[r][1], lheight)]
rheight = right[r][1]
r += 1
# 相等情况
else:
cp = [left[l][0], max(left[l][1], right[r][1])]
lheight = left[l][1]
rheight = right[r][1]
l += 1
r += 1
# 和前面高度比较，不一样才加入
if len(res) == 0 or res[-1][1] != cp[1]:
res.append(cp)
# 剩余部分添加进去
res.extend(left[l:] or right[r:])
return res
227-基本计算器2（python）
class Solution(object):
def calculate(self,s):
num=0
stack=[]
op='+'
for i,c in enumerate(s):
if c.isnumeric():
num=num*10+int(c)
if c in '+-*/' or i==len(s)-1:
if op='+':
stack.append(num)
if op='-':
stack.append(-num)
if op='*':
stack.append(stack.pop()*num)
if op='/':
stack.append(stack.pop()/num)
op=c
num=0
return sum(stack)
242-有效的字母异位词（python）
#排序
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
return sorted(s) == sorted(t)
268-缺失数字（python）
class Solution(object):
def missingNumber(self,nums):
nums_set=set(nums)
n=len(nums)+1
for number in range(n):
if number not in nums_set:
return number
return -1
287-寻找重复数（python）
#排序后比较
class Solution(object):
def findDuplicate(self, nums):
nums.sort()
for i in range(1, len(nums)):
if nums[i] == nums[i-1]:
return nums[i]
289-生命游戏（python）
#统计每个周围有多少活细胞数
class Solution:
def gameOfLife(self, board: List[List[int]]) -> None:
if not board or not board[0]:
return
m, n = len(board), len(board[0])
for i in range(m):
for j in range(n):
cnt = self.count_alive(board, i, j)
if board[i][j] and cnt in [2, 3]:
board[i][j] = 3
if not board[i][j] and cnt == 3:
board[i][j] = 2
for i in range(m):
for j in range(n):
board[i][j] >>= 1
def count_alive(self, board, i, j):
m, n = len(board), len(board[0])
cnt = 0
directions = [(0, 1), (0, -1), (-1, 0), (1, 0),
(1, 1), (1, -1), (-1, 1), (-1, -1)]
for dx, dy in directions:
x, y = i + dx, j + dy
if x < 0 or y < 0 or x == m or y == n:
continue
cnt += board[x][y] & 1
return cnt
295-数据流中的中位数（python）
#用数组存，排序找中位数
class MedianFinder:
def __init__(self):
self.store = []
def addNum(self, num: int) -> None:
self.store.append(num)
def findMedian(self) -> float:
self.store.sort()
n = len(self.store)
if n & 1 == 1: # n 是奇数
return self.store[n // 2]
else:
return (self.store[n // 2 - 1] + self.store[n // 2]) / 2
300-最长上升子序列（python）
#动态规划
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
if not nums:
return 0
dp=[1]*len(nums)
for i in range(len(nums)):
for j in range(i):
if nums[j]<nums[i]:
dp[i]=max(dp[i],dp[j]+1)
return max(dp)
315-计算右侧小于当前元素个数（python）
#输入数组反过来插入一个有序数组（降序）中，插入的位置就是在原数组中位于它右侧的元素的个数
class Solution(object):
def countSmaller(self, nums):
sortns = []
res = []
for n in reversed(nums):
idx = bisect.bisect_left(sortns, n)
res.append(idx)
sortns.insert(idx,n)
return res[::-1]
324-摆动排序（python）
#利用排序 进行插入
class Solution:
def wiggleSort(self, nums: List[int]) -> None:
nums.sort(reverse=True)
mid=len(nums)//2
nums[1::2],nums[0::2]=nums[:mid],nums[mid:]
326-3的幂（python）
class Solution(object):
def isPowerOfTree(self,n):
if n<1:return False
while n%3==0:
n/=3
return n==1
328-奇偶链表（python）
class Solution(object):
def oddEvenlist(self,head):
if not head:return head
p=head
t=q=p.next
while q and q.next:
p.next=q.next
q.next=q.next.next
p=p.next
q=q.next
p.next=t
return head
329-矩阵中的最长递增路径（python）
class Solution(object):
def longestIncreasingPath(self, matrix):
if not matrix:
return 0
len_r=len(matrix)
len_c=len(matrix[0])
dis=[[1,0],[-1,0],[0,1],[0,-1]]
ans=0
mon=[[0]*len_c for _ in range(len_r)]
for nr in range(len_r):
for nc in range(len_c):
ans=max(ans,self.dfs(matrix,nr,nc,dis,mon))
return ans
def dfs(self,matrix,r,c,dis,mon):
if mon[r][c]!=0:
return mon[r][c]
longest=1
for d in dis:
x=r+d[0]
y=c+d[1]
if x>=0 and x<len(matrix) and y>=0 and y<len(matrix[0]) and matrix[r][c]<matrix[x][y]:
longest=max(longest,1+self.dfs(matrix,x,y,dis,mon))
mon[r][c]=longest
return mon[r][c]
334-递增三元子序列（python）
class Solution(object):
def iscreasingTriplet(self,nums):
if len(nums)<3:return False
win=[nums[0]]
for num in nums:
if num>win[-1]:
win.append(num)
if len(win)>=3:
return True
else:
i=len(win)-1
if i>0 and win[i-1]>=num:
i-=1
win[i]=num
return False
350-两数组的交集2（python）
class Solution(object):
def intersect(self,nums1,nums2):
if len(nums1)>len(nums2):
return self.intersect(nums2,nums1)
hash={}
for num in nums1:
hash[nums]=hash.get(num,0)+1
res=[]
for num in nums2:
if num in hash and hash[num]>0:
res.append(num)
hash[num]-=1
return res
371-两整数之和（python）
class Solution(object):
def getSum(self, a, b):
c = []
c.append(a)
c.append(b)
return sum(c)
378-有序矩阵中第K小的元素（python）
#左上角最小 右下角最大 二分法查找
class Solution(object):
def kthSmallest(self, matrix, k):
# 计算小于等于目标值的元素个数，根据递增规则，从右上角开始查找
def count_num(m, target):
i = 0
j = len(m) - 1
ans = 0
while i < len(m) and j >= 0:
if m[i][j] <= target:
ans += j + 1
i += 1
else:
j -= 1
return ans
# 思路：左上角元素最小，右下角元素最大，计算小于等于中间值的元素个数
left = matrix[0][0]
right = matrix[-1][-1]
# 二分法查找
while left < right:
mid = (left + right) //2
# print(' mid = ', mid)
count = count_num(matrix, mid)
# print('count = ', count)
if count < k:
left = mid + 1
else:
right = mid
return left
380-常数时间插入、删除和获取随机元素（python）
class RandomizedSet:
def __init__(self):
"""
Initialize your data structure here.
"""
self.dict = {}
self.list = []
def insert(self, val: int) -> bool:
"""
Inserts a value to the set. Returns true if the set did not already contain the specified element.
"""
if val in self.dict:
return False
self.dict[val] = len(self.list)
self.list.append(val)
return True
def remove(self, val: int) -> bool:
"""
Removes a value from the set. Returns true if the set contained the specified element.
"""
if val in self.dict:
# move the last element to the place idx of the element to delete
last_element, idx = self.list[-1], self.dict[val]
self.list[idx], self.dict[last_element] = last_element, idx
# delete the last element
self.list.pop()
del self.dict[val]
return True
return False
def getRandom(self) -> int:
"""
Get a random element from the set.
"""
return self.list[random.randint(0, len(self.list) - 1)]
380-常数时间插入、删除和获取随机元素（python）
#哈希
class RandomizedSet:
def __init__(self):
"""
Initialize your data structure here.
"""
self.dict = {}
self.list = []
def insert(self, val: int) -> bool:
"""
Inserts a value to the set. Returns true if the set did not already contain the specified element.
"""
if val in self.dict:
return False
self.dict[val] = len(self.list)
self.list.append(val)
return True
def remove(self, val: int) -> bool:
"""
Removes a value from the set. Returns true if the set contained the specified element.
"""
if val in self.dict:
# move the last element to the place idx of the element to delete
last_element, idx = self.list[-1], self.dict[val]
self.list[idx], self.dict[last_element] = last_element, idx
# delete the last element
self.list.pop()
del self.dict[val]
return True
return False
def getRandom(self) -> int:
"""
Get a random element from the set.
"""
return self.list[random.randint(0, len(self.list) - 1)]
384-打乱数组（python）
class Solution(object):
def __init__(self, nums):
self.nums = nums
def reset(self):
return self.nums
def shuffle(self):
array = copy.copy(self.nums)
for i in range(len(array)):
random_num = random.randint(i,len(array)-1)
array[i], array[random_num] = array[random_num], array[i]
return array
387-字符串中第一个唯一字符（python）
class Solution(object):
def firstUniqchar(self,s):
dicts={}
for i in s:
dicts[i]=dicts.get(i,0)+1
for i in range(len(s)):
if dicts[s[i]]==1:
return i
return -1
395-至少有K个重复字符的最长子串（python）
class Solution(object):
def longestSubstring(self, s, k):
def find(s, k, left, right):
if left > right:
return 0
# 用字典存储所有字符出现的情况
hash_map = dict()
for i in range(left, right + 1):
c = s[i]
if hash_map.get(c, None) == None:
hash_map[c] = []
hash_map[c].append(i)#这是一数组
for key in hash_map.keys():
# 某个字符出现的次数
counter = len(hash_map[key])
# 如果字符出现次数 < k，那么该字符不可能出现在最终要求的子串中，在该字符的位置对原字符串进行截断
if counter > 0 and counter < k:
# 该字符首次出现的位置
pos = hash_map[key][0]
# 根据该字符的位置对字符串进行截断，判断左右两个截断的字字符哪个更长
return max(find(s, k, left, pos - 1), find(s, k, pos + 1, right))
return right - left + 1
return find(s, k, 0, len(s) - 1)
412-FizzBuzz（python）
class Solution(object):
def fizzBuzz(self,n):
ans=[]
for i in range(1,n+1):
div_by_3=(i%3==0)
div_by_5=(i%5==0)
if div_by_3 and div_by_5:
ans.append("FizzBUzz")
elif div_by_3:
ans.append("Fizz")
elif div_by_5:
ans.append("Buzz")
else:
ans.append(i)
return ans
454-四数相加2（python）
#key-value
class Solution(object):
def fourSumCount(self,A,B,C,D):
lookup=collections.defaultdict(int)
res=0
for a in A:
for b in B:
lookup[a+b]+=1
for c in C:
for d in D:
res+=lookup[-(c+d)]
return res