解题思路
二叉树解题的思维模式分两类:
1、是否可以通过遍历一遍二叉树得到答案?如果可以,用一个 traverse 函数配合外部变量来实现,这叫「遍历」的思维模式。
2、是否可以定义一个递归函数,通过子问题(子树)的答案推导出原问题的答案?如果可以,写出这个递归函数的定义,并充分利用这个函数的返回值,这叫「分解问题」的思维模式。
无论使用哪种思维模式,你都需要思考:
如果单独抽出一个二叉树节点,它需要做什么事情?需要在什么时候(前/中/后序位置)做?其他的节点不用你操心,递归函数会帮你在所有节点上执行相同的操作。
二叉树中用遍历思路解题时函数签名一般是 void traverse(…),没有返回值,靠更新外部变量来计算结果,而用分解问题思路解题时函数名根据该函数具体功能而定,而且一般会有返回值,返回值是子问题的计算结果。
104. 二叉树的最大深度
104. 二叉树的最大深度
遍历方式
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def __init__(self):
self.ans = 0
self.depth = 0
def maxDepth(self, root: Optional[TreeNode]) -> int:
self.traverse(root)
return self.ans
def traverse(self, root:Optional[TreeNode]):
if not root:
return
self.depth += 1
self.ans = max(self.ans, self.depth)
self.traverse(root.left)
self.traverse(root.right)
self.depth -= 1
分解方式
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def maxDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
left_max = self.maxDepth(root.left)
right_max = self.maxDepth(root.right)
return max(left_max, right_max) + 1
226. 翻转二叉树
226. 翻转二叉树
遍历方式
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
self.traceverse(root)
return root
def traceverse(self, root: Optional[TreeNode]):
if not root:
return
root.left, root.right = root.right, root.left
self.traceverse(root.left)
self.traceverse(root.right)
分解方式
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
if not root:
return None
left = self.invertTree(root.left)
right = self.invertTree(root.right)
root.left, root.right = right, left
return root
116. 填充每个节点的下一个右侧节点指针
import collections
class Solution:
def connect(self, root: 'Node') -> 'Node':
if not root:
return root
# 初始化队列同时将第一层节点加入队列中,即根节点
Q = collections.deque([root])
# 外层的 while 循环迭代的是层数
while Q:
# 记录当前队列大小
size = len(Q)
# 遍历这一层的所有节点
for i in range(size):
# 从队首取出元素
node = Q.popleft()
# 连接
if i < size - 1:
node.next = Q[0]
# 拓展下一层节点
if node.left:
Q.append(node.left)
if node.right:
Q.append(node.right)
# 返回根节点
return root
114. 二叉树展开为链表
114. 二叉树展开为链表
分解方式
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def flatten(self, root: Optional[TreeNode]) -> None:
"""
Do not return anything, modify root in-place instead.
"""
# base case
if not root:
return
# 利用定义,把左右子树拉平
self.flatten(root.left)
self.flatten(root.right)
# 后序遍历位置
# 1、左右子树已经被拉平成一条链表
left = root.left
right = root.right
# 2、将左子树作为右子树
root.left = None
root.right = left
# 3、将原先的右子树接到当前右子树的末端
p = root
while p.right:
p = p.right
p.right = right
1110. 删点成林
1110. 删点成林
本题的难点在于返回根节点,并且还要修改二叉树
分解方式
class Solution:
def delNodes(self, root: Optional[TreeNode], to_delete: List[int]) -> List[TreeNode]:
to_delete_set = set(to_delete)
roots = []
self.dfs(root, True, to_delete_set, roots)
return roots
def dfs(self, node: Optional[TreeNode], is_root: bool, to_delete_set: set[int], roots: List[TreeNode]) -> Optional[TreeNode]:
if node == None:
return None
delete = node.val in to_delete_set
node.left = self.dfs(node.left, delete, to_delete_set, roots)
node.right = self.dfs(node.right, delete, to_delete_set, roots)
if delete:
return None
else:
if is_root:
roots.append(node)
return node
二叉搜索树
二叉搜索树(BST)的特性如下:
1、对于 BST 的每一个节点 node,左子树节点的值都比 node 的值要小,右子树节点的值都比 node 的值大。
2、对于 BST的每一个节点 node,它的左侧子树和右侧子树都是 BST。
BST有一个重要的性质:BST 的中序遍历结果是有序的(升序)。
230. 二叉搜索树中第K小的元素
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def __init__(self):
self.ans = []
def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
self.backtrace(root)
return self.ans[k - 1]
def backtrace(self, root: Optional[TreeNode]):
if not root:
return
self.backtrace(root.left)
self.ans.append(root.val)
self.backtrace(root.right)
538. 把二叉搜索树转换为累加树
此题中序遍历的顺序不一样
538. 把二叉搜索树转换为累加树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
self.backtrace(root, [0])
return root
def backtrace(self, root: Optional[TreeNode], sum):
if not root:
return
self.backtrace(root.right, sum)
sum[0] += root.val
root.val = sum[0]
self.backtrace(root.left, sum)
参考链接:https://labuladong.gitee.io/algo/di-yi-zhan-da78c/shou-ba-sh-66994/dong-ge-da-8f403/
参考链接
https://labuladong.gitee.io/algo/di-yi-zhan-da78c/shou-ba-sh-66994/dong-ge-da-334dd/