leetcode刷题

最新推荐文章于 2025-07-27 20:50:25 发布

原创最新推荐文章于 2025-07-27 20:50:25 发布 · 374 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python

pyer 专栏收录该内容

22 篇文章

订阅专栏

本文介绍了多种二叉树的操作方法，包括判断二叉树是否平衡、查找最底层最左边的节点值、二叉树的前序遍历及在二叉搜索树中查找第k小的元素等。此外还涉及了图的二分性和课程依赖关系的解决方法。

110 平衡二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None

class Solution:
def isBalanced(self, root: TreeNode) -> bool:
if not root:
return True
if abs(self.getheight(root.left)-self.getheight(root.right))>1:
return False
else:
return self.isBalanced(root.left) and self.isBalanced(root.right)##确保每个节点的左右子树都满足要求
def getheight(self,root):##计算树高度
if not root:
return 0
else:
left=self.getheight(root.left)
right=self.getheight(root.right)
return max(left,right)+1
513
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None

class Solution:
def findBottomLeftValue(self, root: TreeNode) -> int:
####3求取最左端节点元素
queue=[root]
l_node=0
while queue:
l_node=queue[0].val
temp=[]###逐层遍历寻找最左端
for i in queue:
if i.left:
temp.append(i.left)
if i.right:
temp.append(i.right)
queue=temp
return l_node
144
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None

class Solution:

def preorderTraversal(self, root: TreeNode) -> List[int]:

####递归法
# if not root:
# return []
# res=[root.val]
# l=self.preorderTraversal(root.left)
# r=self.preorderTraversal(root.right)
# return res+l+r
######迭代方法
if root is None:
return []
stack = []
result = []
stack.append(root)
while(len(stack) > 0):
node = stack.pop()
result.append(node.val)
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return result
230 二叉搜索树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None

class Solution:
def kthSmallest(self, root, k):
self.num = k
result, flag = self.pre_search(root)
if flag:
return result.val
else:
return 0

def pre_search(self, root):
#返回的第二个值表示是否找到第k个值
if not root:
return -1, False
else:
left, flag = self.pre_search(root.left)
if flag:
return left, True
self.num -= 1
if self.num == 0:
return root, True
right, flag = self.pre_search(root.right)
if flag:
return right, True
return -1, False
208前缀树
class Trie:

def __init__(self):
"""
Initialize your data structure here.
"""
self.root = {}

def insert(self, word: str) -> None:
"""
Inserts a word into the trie.
"""
node = self.root
for s in word:
if s in node.keys():
node = node[s]
else:
node[s] = {}
node = node[s]
node['is_word'] = True

def search(self, word: str) -> bool:
"""
Returns if the word is in the trie.
"""
node = self.root
for s in word:
if s in node.keys():
node = node[s]
else:
return False

if 'is_word' in node.keys():
return True
else:
return False

def startsWith(self, prefix: str) -> bool:
"""
Returns if there is any word in the trie that starts with the given prefix.
"""
node = self.root
for s in prefix:
if s in node.keys():
node = node[s]
else:
return False

return True
785
class Solution:
def isBipartite(self, graph: List[List[int]]) -> bool:
n = len(graph)
colors = [0] * n
# 0 未被染色的 1 是红色 -1 是蓝色
def dfs(i,color):
if colors[i] != 0:
return colors[i] == color
colors[i] = color
for j in graph[i]:
if not dfs(j,-color):
return False
return True
for i in range(n):
if colors[i] == 0 and not dfs(i,1):
return False
return True
207
class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
# 课程的长度
clen = len(prerequisites)
if clen == 0:
# 没有课程，当然可以完成课程的学习
return True
# 入度数组，一开始全部为 0
in_degrees = [0 for _ in range(numCourses)]
# 邻接表
adj = [set() for _ in range(numCourses)]

# 想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
# [0,1] 表示 1 在先，0 在后
# 注意：邻接表存放的是后继 successor 结点的集合
for second, first in prerequisites:
in_degrees[second] += 1
adj[first].add(second)

# print("in_degrees", in_degrees)
# 首先遍历一遍，把所有入度为 0 的结点加入队列
res = []
queue = []
for i in range(numCourses):
if in_degrees[i] == 0:
queue.append(i)
counter = 0
while queue:
top = queue.pop(0)
counter += 1

for successor in adj[top]:
in_degrees[successor] -= 1
if in_degrees[successor] == 0:
queue.append(successor)

return counter == numCourses
684
class Solution:
def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
"""
:type edges: List[List[int]]
:rtype: List[int]
"""
n = len(edges)
parent = list(range(n+1)) # 索引对应边的索引，索引0冗余
s = []
def find(x):
if x == parent[x]:
return x
else:
return find(parent[x]) # 最终返回“由相互邻接组成的连通图”的最大索引
def union(u, v):
x = find(u)
y = find(v)
if x == y:
s.append([u, v])
elif x > y:
parent[y] = x
else:
parent[x] = y
for u, v in edges:
union(u, v)
# print(s)
# print(parent)
return s[-1]