94. 二叉树的中序遍历
class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
res = []
if not root:
return res
def dfs(root):
if not root:
return
dfs(root.left)
res.append(root.val)
dfs(root.right)
dfs(root)
return res
104. 二叉树的最大深度
class Solution:
def maxDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
def dfs(root, p):
if root is None:
return p
return max(dfs(root.left, p + 1), dfs(root.right, p + 1))
return dfs(root, 0)
226. 翻转二叉树
class Solution:
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
if root is None:
return root
self.invertTree(root.left)
self.invertTree(root.right)
t = root.left
root.left = root.right
root.right = t
return root
101. 对称二叉树
class Solution:
def isSymmetric(self, root: Optional[TreeNode]) -> bool:
def dfs(ll, rr):
# 这里判空，顺带判断了是否对称，太秒了
if not ll or not rr:
return ll == rr
return ll.val == rr.val and dfs(ll.left, rr.right) and dfs(ll.right, rr.left)
return dfs(root.left, root.right)
543. 二叉树的直径
因为每个点的直径信息不能直接递归返回，所以只能声明一个全局的res进行保存
每个点返回的信息为左右子树的最大深度
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
# 因为每个点的直径信息不能直接递归返回，所以只能声明一个全局的res进行保存，
# 每个点返回的信息为左右子树的最大深度
res = 0
def dfs(root):
nonlocal res
if root is None:
return -1
ll = dfs(root.left)
rr = dfs(root.right)
res = max(res, ll + rr + 2)
return max(ll, rr) + 1
dfs(root)
return res
102. 二叉树的层序遍历
class Solution:
def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
res = []
if root is None:
return res
def bfs(root):
q = deque()
q.append(root)
while q:
k = len(q)
aa = []
while k:
e = q.popleft()
aa.append(e.val)
if e.left:
q.append(e.left)
if e.right:
q.append(e.right)
k -= 1
res.append(aa)
bfs(root)
return res
108. 将有序数组转换为二叉搜索树
思路：因为列表由小到大排序，所以列表的中间位置的值可以作为root，构建BST。
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
n = len(nums)
def dfs(l, r):
if l > r:
return None
mid = l + r >> 1
node = TreeNode(nums[mid])
node.left = dfs(l, mid - 1)
node.right = dfs(mid + 1, r)
return node
return dfs(0, n - 1)
