构建树形算法思维框架：从递归分治到高频解题模式

树形算法递归分治

于 2026-08-31 04:19:39 修改

·本内容遵循CC 4.0 BY-SA版权协议

你是不是也经历过这样的场景：LeetCode 上二叉树、递归的题目刷了上百道，感觉自己已经“掌握”了。然而，当面试官抛出一道你没见过的、稍微变形的“树”相关题目时，大脑瞬间一片空白，不知从何下手。你明明记得前序、中序、后序遍历的代码模板，也做过路径和、最近公共祖先，但为什么新题就是解不出来？

问题不在于你刷题的数量，而在于你刷题的方式。大多数人的刷题停留在“记忆解法”的层面，而面试考察的是“问题分解与建模”的能力。“树”不仅仅是一种数据结构，更是一种强大的递归思维模型和问题抽象工具。 如果你只记住了“二叉树用递归”，而没有理解递归背后“分治”与“状态传递”的本质，没有建立起从具体问题到树模型的映射能力，那么遇到新题必然卡壳。

这篇文章，我们不谈具体的 100 道树题解法，而是深入一层，解决那个更根本的问题：如何建立一套以“树”为核心的算法思维框架，让你面对任何树相关新题时，都能有清晰的破题思路。 我们将从递归的本质出发，拆解树问题的核心模式，并通过几个典型的“变形题”实战，带你完成从“背题”到“解题”的思维跃迁。无论你是正在备战 SDE 面试的求职者，还是希望夯实算法基础的在职工程师，这篇文章都将为你提供一套可复用的方法论。

1. 为什么刷了很多树题，遇到新题还是不会？

在深入技术细节前，我们必须先诊断问题的根源。通常，无效的刷题会陷入以下几个陷阱：

陷阱一：停留在“背诵”层面，而非“理解”层面。 你熟练地写出了 dfs(root.left) 和 dfs(root.right)，但可能从未深入思考：递归函数到底代表什么语义？它每次调用是解决原问题的子问题，还是在收集信息？返回值是最终答案，还是中间状态？当题目从“求最大深度”变为“判断平衡二叉树”时，仅仅记住后序遍历的模板是不够的，你必须理解为什么后序遍历适合解决这个问题（因为需要子树的信息）。

陷阱二：缺乏对问题模式的抽象归类。 树的问题看似千变万化，但核心的解题模式不超过十种。例如：

遍历模式：前中后序、层次遍历。
分治模式：大部分递归题目，将问题分解为左子树、右子树和当前节点。
路径模式：从根到叶子的路径相关问题，常需要回溯。
父子信息传递模式：需要从子节点向父节点返回信息（如子树和、高度），或从父节点向子节点传递信息（如路径和、节点值约束）。如果你没有有意识地将做过的题目归纳到这些模式中，那么每道题对你来说都是孤立的“新题”。

陷阱三：忽视“树”作为问题模型的通用性。 许多非显式树结构的问题，本质上也是树问题。例如：

文件系统的目录遍历（N叉树）。
公司组织架构（多叉树）。
递归回溯问题（如全排列），其递归调用栈形成的是一棵“递归树”。
动态规划中的状态转移，有时也可以看作在一棵“决策树”上搜索。如果你只把“树”理解为 TreeNode 那个数据结构，你的思维就被局限了。

陷阱四：没有建立“从问题描述到解法设计”的思维链路。 面对新题，高手会问自己一系列问题：

这个问题能分解为子问题吗？（识别递归/分治可能性）
解决子问题需要哪些信息？子问题的解如何合并成原问题的解？（定义递归函数返回值）
在遍历过程中，需要维护哪些额外状态？（定义递归函数参数或全局变量）
遍历的顺序是什么？（前序、中序、后序？）而很多求职者直接跳到了第4步，试图套用记忆中的模板，自然无法奏效。

接下来的内容，我们将围绕如何打破这些陷阱展开，构建一套系统的树问题求解框架。

2. 核心思维框架：递归、分治与状态管理

要真正掌握树问题，必须吃透三个核心概念：递归、分治、状态管理。它们是解开所有树形结构问题的万能钥匙。

2.1 递归：树与生俱来的语言

递归是描述树的最自然方式。一个递归函数 f(node) 通常包含三个部分：

递归终止条件：对应到树的叶子节点或空节点。
递归调用：处理左子树 f(node.left) 和右子树 f(node.right)。
本次调用处理逻辑：利用左右子树返回的结果，计算并返回当前节点的结果。

关键洞察：递归函数的定义决定了你能解决什么问题。你必须非常清楚你的函数 f(node) 代表什么。

是“以 node 为根的子树的最大深度”吗？
是“以 node 为根的子树中，是否存在一条路径和为 targetSum”吗？
还是“以 node 为根的子树是否是二叉搜索树”？

定义清晰后，代码几乎是自然流露的。

2.2 分治：化整为零的策略

分治是递归最常见的应用场景。它将一个大规模问题（整棵树）分解为若干个规模较小但形式相同的子问题（左子树、右子树），分别解决后再合并结果。

经典模式：

PYTHON

def divide_conquer(root):

# 1. 递归终止：空节点如何处理？

if not root:

return ... # 通常返回一个中性值，如0，None，空列表等

# 2. 分：递归解决子问题

left_result = divide_conquer(root.left)

right_result = divide_conquer(root.right)

# 3. 治：合并子问题的结果，并考虑当前节点

result = merge(left_result, right_result, root.val)

# 4. 返回当前子树的结果

return result

LeetCode 104. 二叉树的最大深度、110. 平衡二叉树、124. 二叉树中的最大路径和（部分思路）都是典型的分治应用。

2.3 状态管理：信息在树中的流动

这是区分普通解题者和高手的关键。在树中解决问题，本质是在节点间传递和聚合信息。状态管理有两种主要方向：

自底向上（后序遍历）：子节点将信息返回给父节点。
- 场景：需要利用子树的信息来计算当前节点的信息。
- 示例：计算树的高度、判断平衡二叉树、计算子树节点数。
- 实现：递归函数的返回值就是需要传递的信息。
自顶向下（前序遍历）：父节点将信息传递给子节点。
- 场景：需要将根节点已知的约束或状态向下传递。
- 示例：记录从根到当前节点的路径和、判断从根到叶子的路径是否符合条件。
- 实现：通过递归函数的参数将状态向下传递。
全局状态记录：在遍历过程中，维护一个全局变量（或引用传递的参数）来记录最终答案或中间状态。
- 场景：最终答案并非某个子树的返回值，而是在遍历过程中产生的某个极值（如最大路径和、最大直径）。
- 示例：LeetCode 543. 二叉树的直径。直径是左子树深度+右子树深度的最大值，这个最大值可能在任意节点产生，因此需要一个全局变量 max_diameter 在递归过程中不断更新。

理解你需要管理哪些状态，以及状态流动的方向，是设计递归函数签名（参数和返回值）的基础。

3. 五大高频解题模式深度解析

基于上述思维框架，我们可以将常见的树面试题归纳为几种核心模式。掌握模式，而非孤立的题目。

3.1 模式一：遍历与搜索（基础）

这是最直接的模式，但关键在于理解不同遍历顺序的适用场景。

前序遍历：根 -> 左 -> 右。适合需要先访问当前节点，再处理子树的场景，如复制一棵树、序列化。
中序遍历：左 -> 根 -> 右。在二叉搜索树（BST） 中，能得到有序序列。用于验证BST、恢复BST、BST转链表等。
后序遍历：左 -> 右 -> 根。适合需要先得到子树结果，再处理当前节点的场景，这是分治和自底向上信息传递的典型，如计算节点数、树高、路径和。
层次遍历（BFS）：使用队列。适合按层处理节点，如寻找每层最大值、锯齿形遍历、最短路径（在树中即最小深度）。

代码示例：递归与迭代实现后序遍历

PYTHON

# 递归实现（隐式栈）

def postorderTraversal(root):

result = []

def dfs(node):

if not node:

return

dfs(node.left) # 左

dfs(node.right) # 右

result.append(node.val) # 根

dfs(root)

return result

# 迭代实现（显式栈）- 一种取巧的方法：仿前序，再反转

def postorderTraversalIterative(root):

if not root:

return []

stack, output = [root], []

while stack:

node = stack.pop()

output.append(node.val)

# 注意入栈顺序：先左后右，这样出栈顺序才是右->左，反转后变成左->右->根

if node.left:

stack.append(node.left)

if node.right:

stack.append(node.right)

return output[::-1] # 关键：反转结果

思考：为什么后序遍历的迭代写法比前序和中序更复杂？因为它需要判断当前节点的左右子树是否都已处理完毕。上面的“取巧”方法利用了“前序是根左右，后序是左右根，将前序稍作修改再反转即可得到后序”的规律，但理解其原理有助于加深对遍历过程的认识。

3.2 模式二：路径问题（回溯）

路径问题通常要求找到从根节点到叶子节点满足特定条件的路径。这类问题的核心是在深度优先搜索（DFS）中引入回溯。

解题模板：

使用前序遍历，在进入节点时将节点加入路径。
递归探索左右子树。
在离开节点时（即左右子树都探索完后），将节点从路径中移除（回溯）。
在叶子节点或满足条件的节点处，记录当前路径。

示例：LeetCode 113. 路径总和 II

PYTHON

class Solution:

def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:

def dfs(node, current_sum, path):

if not node:

return

# 1. 处理当前节点

current_sum += node.val

path.append(node.val)

# 2. 判断是否为叶子节点且路径和符合条件

if not node.left and not node.right and current_sum == targetSum:

# 注意：需要添加path的副本，因为path后续会被修改

result.append(path[:])

# 3. 递归探索左右子树

dfs(node.left, current_sum, path)

dfs(node.right, current_sum, path)

# 4. 回溯：离开节点前，从路径中移除当前节点

path.pop()

result = []

dfs(root, 0, [])

return result

关键点：path.append() 和 path.pop() 必须成对出现，确保递归调用栈回退时，路径状态也同步回退。result.append(path[:]) 中的 [:] 是创建列表副本，避免后续回溯修改了已存入结果中的路径。

3.3 模式三：子树与属性判断（分治）

判断一棵树或其子树是否具有某种属性（如平衡、对称、二叉搜索树）。这类问题完美契合分治思想。

解题思路：

定义递归函数，明确其返回值的含义（例如，返回子树的高度、是否平衡、最大值、最小值等）。
在递归函数内部： a. 处理空节点基准情况。 b. 递归获取左右子树的信息。 c. 综合左右子树信息和当前节点，判断属性是否成立，并计算需要返回的信息。 d. 有时需要设置全局变量或特殊返回值来标记失败情况。

示例：LeetCode 98. 验证二叉搜索树 常见的错误是只检查 node.left.val < node.val < node.right.val。BST 的定义要求整个左子树的所有节点都小于根，整个右子树的所有节点都大于根。因此，我们需要在递归时传递当前子树允许的数值范围 (lower, upper)。

PYTHON

class Solution:

def isValidBST(self, root: Optional[TreeNode]) -> bool:

def dfs(node, lower=float('-inf'), upper=float('inf')):

# 递归终止条件

if not node:

return True

# 当前节点值必须在 (lower, upper) 开区间内

if not (lower < node.val < upper):

return False

# 递归检查左右子树，并更新上下界

# 左子树的所有节点值必须小于 node.val，故上界更新为 node.val

# 右子树的所有节点值必须大于 node.val，故下界更新为 node.val

return dfs(node.left, lower, node.val) and dfs(node.right, node.val, upper)

return dfs(root)

进阶思考：也可以利用 BST 中序遍历有序的性质来解决。但上述“传递边界”的方法更通用，体现了“自顶向下传递约束”的状态管理思想。

3.4 模式四：构造与转换

根据给定条件构造一棵树，或将一棵树转换成另一种形式。这类问题需要深刻理解树的结构与遍历序列之间的关系。

核心关系：

前序 + 中序 可以唯一确定一棵二叉树。前序确定根，中序划分左右子树。
后序 + 中序 可以唯一确定一棵二叉树。后序确定根，中序划分左右子树。
仅前序和后序 无法唯一确定二叉树（除非是真二叉树）。

示例：LeetCode 105. 从前序与中序遍历序列构造二叉树

PYTHON

class Solution:

def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:

# 构建中序序列值到索引的映射，便于快速定位根节点

inorder_index_map = {val: idx for idx, val in enumerate(inorder)}

def build(pre_start, pre_end, in_start, in_end):

if pre_start > pre_end:

return None

# 前序遍历的第一个节点是根节点

root_val = preorder[pre_start]

root = TreeNode(root_val)

# 在中序遍历中找到根节点的位置

in_root_idx = inorder_index_map[root_val]

# 计算左子树的节点个数

left_subtree_size = in_root_idx - in_start

# 递归构建左右子树

# 左子树的前序区间: [pre_start+1, pre_start+left_subtree_size]

# 左子树的中序区间: [in_start, in_root_idx-1]

root.left = build(pre_start + 1, pre_start + left_subtree_size,

in_start, in_root_idx - 1)

# 右子树的前序区间: [pre_start+left_subtree_size+1, pre_end]

# 右子树的中序区间: [in_root_idx+1, in_end]

root.right = build(pre_start + left_subtree_size + 1, pre_end,

in_root_idx + 1, in_end)

return root

return build(0, len(preorder) - 1, 0, len(inorder) - 1)

关键点：通过中序序列中根节点的位置，可以精确计算出左右子树在前序和中序序列中的边界。递归函数 build 的参数就是这些边界索引。避免在递归中创建列表切片（list slicing），而是传递索引，可以大幅提升性能。

3.5 模式五：最近公共祖先（LCA）与节点关系

寻找两个节点的最近公共祖先（LCA）是面试超级高频题。其变种包括寻找两个节点间的距离等。

解题思路（递归分治）：对于以 root 为根的树，寻找 p 和 q 的 LCA：

如果 root 是 None，或者 root 等于 p 或 q，则返回 root。
递归在左子树中寻找 LCA，得到 left。
递归在右子树中寻找 LCA，得到 right。
如果 left 和 right 都不为空，说明 p 和 q 分别位于 root 的左右子树中，那么 root 就是 LCA。
如果一边为空，则 LCA 在另一边。

示例：LeetCode 236. 二叉树的最近公共祖先

PYTHON

class Solution:

def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':

# 递归终止条件：找到节点或到达空节点

if not root or root == p or root == q:

return root

# 分治：在左右子树中寻找 p 和 q

left = self.lowestCommonAncestor(root.left, p, q)

right = self.lowestCommonAncestor(root.right, p, q)

# 治：根据左右子树的结果判断

if left and right:

# p和q分居左右子树，当前root是LCA

return root

# 如果一边为空，则LCA在另一边（可能本身就是p或q，或者是更上层的LCA）

return left if left else right

理解：这个解法的精妙之处在于，递归函数 lowestCommonAncestor 的返回值含义很丰富：

如果以 root 为根的子树中包含 p 或 q，则返回该节点。
如果同时包含 p 和 q，则返回它们的 LCA。
如果不包含，则返回 None。这个定义使得上述简洁的递归逻辑成立。

4. 从“新题”到“旧模式”：实战拆解三例

现在，我们用前面建立的思维框架来拆解三道可能让你感到陌生的“新题”，看看如何将它们归类到已知模式。

4.1 例题一：求二叉树中所有距离为 K 的节点（LeetCode 863.）

题目简述：给定一个二叉树，一个目标节点 target，和一个整数 k。返回所有与 target 距离为 k 的节点的值列表。

破题思路：

模式识别：这不是一个简单的子树遍历问题，因为距离为 K 的节点可能在 target 的子树中，也可能在其祖先节点的另一棵子树中。这提示我们需要将树视为无向图。
状态管理与建模：在树上，从一点到另一点只有唯一路径。距离为 K 的节点，就是从 target 节点出发，在树上走 K 步能到达的所有节点。
解题步骤： a. 建图：通过一次遍历，为每个节点记录其父节点，从而将树转化为无向图（每个节点知道其左子、右子、父节点）。 b. BFS搜索：从 target 节点开始，进行 K 层的广度优先搜索（BFS），第 K 层的所有节点即为答案。BFS 能天然保证找到的是最短距离。 c. 避免重复访问：使用哈希集合记录已访问节点。

代码实现：

PYTHON

from collections import deque

class Solution:

def distanceK(self, root: TreeNode, target: TreeNode, k: int) -> List[int]:

# 步骤1：构建父节点映射（DFS）

parent_map = {}

def dfs_build_parent(node, par):

if not node:

return

parent_map[node] = par

dfs_build_parent(node.left, node)

dfs_build_parent(node.right, node)

dfs_build_parent(root, None)

# 步骤2：从target开始BFS

result = []

visited = set([target])

queue = deque([(target, 0)]) # (node, distance)

while queue:

node, dist = queue.popleft()

if dist == k:

result.append(node.val)

# 如果已经找到距离为K的节点，继续遍历同一层的其他节点即可，无需再探索更远

continue

# 向三个方向探索：左子、右子、父节点

for neighbor in (node.left, node.right, parent_map.get(node)):

if neighbor and neighbor not in visited:

visited.add(neighbor)

queue.append((neighbor, dist + 1))

return result

模式映射：本题核心是 “树转无向图” + “BFS求K层邻居” 。它跳出了纯递归的框架，结合了树的遍历（建图）和图的搜索（BFS），考察的是对数据结构本质的理解和灵活运用能力。

4.2 例题二：二叉树的右视图（LeetCode 199.）

题目简述：给定一个二叉树的根节点，想象自己站在它的右侧，返回从右侧看到的节点值（即每层最右边的节点）。

破题思路：

模式识别：按层遍历，取每层最后一个节点。这属于层次遍历（BFS） 模式。
状态管理：在 BFS 过程中，我们需要知道当前遍历到了哪一层，以及该层有哪些节点。
解题步骤： a. 使用队列进行标准的层次遍历。 b. 在遍历每一层时，记录该层的节点列表。 c. 将该层节点列表的最后一个元素（即最右侧节点）加入结果。

代码实现（BFS）：

PYTHON

from collections import deque

class Solution:

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

if not root:

return []

result = []

queue = deque([root])

while queue:

level_size = len(queue)

for i in range(level_size):

node = queue.popleft()

# 如果是当前层的最后一个节点，加入结果

if i == level_size - 1:

result.append(node.val)

if node.left:

queue.append(node.left)

if node.right:

queue.append(node.right)

return result

进阶思考（DFS）：能否用 DFS 解决？可以，采用先访问右子树的深度优先搜索，并记录当前深度。当第一次到达某个深度时，该节点就是该深度下从右边看到的第一个节点。

PYTHON

class Solution:

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

result = []

def dfs(node, depth):

if not node:

return

# 如果当前深度第一次被访问，记录节点值

if depth == len(result):

result.append(node.val)

# 优先遍历右子树，确保每层最先访问到的是最右边的节点

dfs(node.right, depth + 1)

dfs(node.left, depth + 1)

dfs(root, 0)

return result

模式映射：本题是 “层次遍历” 模式的直接应用。DFS 解法则巧妙地利用了遍历顺序和深度信息，体现了对遍历过程的深度控制。

4.3 例题三：将二叉树展开为链表（LeetCode 114.）

题目简述：给定一棵二叉树，原地将它展开为一个单链表，单链表中的节点顺序为二叉树的前序遍历顺序。

破题思路：

模式识别：要求前序遍历顺序，并且要原地修改。这提示我们需要在遍历过程中，改变节点的左右指针指向。
状态管理与递归设计：对于一个节点 root，我们需要： a. 将其左子树展开为链表，并接到 root 的右边。 b. 将其原来的右子树展开为链表，接到左子树链表的末尾。 c. 将 root 的左子树置为 None。这显然是一个后序遍历的过程：先处理好左右子树，再处理当前节点。
关键点：我们需要知道左子树展开后的尾节点，以便将右子树接上去。

代码实现（递归-后序遍历）：

PYTHON

class Solution:

def flatten(self, root: Optional[TreeNode]) -> None:

"""

Do not return anything, modify root in-place instead.

"""

def dfs(node):

"""

返回展开后链表的尾节点

"""

if not node:

return None

# 递归处理左右子树

left_tail = dfs(node.left)

right_tail = dfs(node.right)

# 如果存在左子树，进行“接龙”操作

if node.left:

# 步骤1：左子树链表的头接到node的右边

left_tail.right = node.right

node.right = node.left

# 步骤2：node的左指针置空

node.left = None

# 返回当前子树展开后的尾节点

# 优先级：右尾节点 -> 左尾节点 -> 当前节点（如果没有左右子树）

return right_tail or left_tail or node

dfs(root)

理解：递归函数 dfs 返回当前子树展开后的尾节点。这个返回值至关重要，它让父节点能够将右子树接到左子树的末尾。整个操作在后序遍历的位置进行，保证了在操作当前节点时，其左右子树已经是被展开好的链表。

模式映射：本题是 “后序遍历” + “指针操作” 的经典结合。它要求你在理解遍历顺序的基础上，灵活地操纵节点间的链接关系，是检验是否真正理解二叉树指针的绝佳题目。

5. 面试实战：如何应对一道陌生的树题目

当你在面试中遇到一道没做过的树相关题目时，可以遵循以下思维流程：

冷静与澄清：花1-2分钟仔细读题，向面试官确认理解是否正确（例如，树的定义、输入输出格式、边界条件）。这既是思考，也是沟通。
举例与可视化：在白板或纸上画一个具体的、稍复杂的例子（3-4层）。手动模拟一下题目要求的过程。这能帮你发现规律。
模式匹配：快速与已知的五大模式进行匹配。
- 是否需要遍历所有节点？（遍历模式）
- 问题能否分解为左子树、右子树的子问题？（分治模式）
- 是否涉及从根到叶子的路径？（路径回溯模式）
- 是否需要判断整棵树或子树的某种属性？（属性判断模式）
- 是否与节点的父子、祖先关系有关？（LCA模式）
- 是否需要改变树的结构？（构造转换模式）
设计递归函数：这是最关键的一步。问自己：
- 递归函数 f(node) 的返回值应该是什么？（是最终答案的一部分，还是中间状态？）
- 递归函数需要哪些参数？（除了 node，是否需要传递额外状态，如路径和、深度、上下界？）
- 递归的终止条件是什么？（通常是 node == null）
- 如何利用左右子树的返回值，结合当前节点，得到本层的返回值？（分治合并）
考虑边界与优化：
- 空树如何处理？
- 单节点树呢？
- 递归深度是否可能过大（栈溢出）？是否需要考虑迭代写法？
- 是否有重复计算？能否用记忆化（Memoization）优化？
代码实现与测试：用你画的例子作为测试用例，走一遍代码。口头解释你的代码逻辑。
分析复杂度：给出时间复杂度和空间复杂度分析。

6. 常见陷阱与最佳实践

6.1 递归的陷阱

栈溢出：对于极度不平衡的树（如链表状的树），递归深度可能达到 O(N)，在某些语言或环境下可能导致栈溢出。面试中需要提及，实际工程中对于深度不可控的数据，可考虑迭代解法或尾递归优化（如果语言支持）。
重复计算：例如在计算“二叉树直径”时，如果单独计算深度再计算直径，会有大量重复。最佳实践是在计算深度的递归过程中，同时更新直径。
修改遍历的副作用：在遍历过程中，如果你修改了节点的结构（如 flatten 题目），要确保不会影响后续的遍历。后序遍历通常是安全的。

6.2 迭代实现的必要性

虽然递归更简洁，但面试官有时会要求写出迭代版本。你必须掌握：

使用栈模拟递归，实现前序、中序、后序遍历。
使用队列实现层次遍历。
使用 Morris 遍历实现空间复杂度 O(1) 的中序遍历（加分项）。

6.3 全局变量 vs 函数返回值

当最终答案是在遍历过程中产生的某个全局最优值（如最大路径和、最大直径）时，使用成员变量或引用传递的列表来记录。
当递归函数本身返回的信息就是子问题的解，并且父问题需要这些解来合并时，使用返回值。

6.4 测试用例设计

自己练习时，要有意识地构造多种测试用例：

空树。
单节点树。
完全二叉树、满二叉树。
只有左子树的树、只有右子树的树（链表）。
普通的不平衡树。

7. 总结与进阶学习方向

刷树题的目的，绝不是为了记住 dfs(root.left) 和 dfs(root.right) 这两行代码。其核心价值在于训练一种递归的、分治的、基于树状结构分解问题的算法思维。这种思维是解决许多复杂问题（如动态规划、回溯、图论中的DFS）的基础。

下一步你可以做什么？

主题式刷题：将 LeetCode 上所有“Tree”标签的题目，按照本文的五大模式进行分类重刷。每刷一道题，都问自己：“这道题属于哪个模式？它的递归函数是如何定义的？状态是如何传递的？”
一题多解：对于经典题目（如三种遍历、最大深度、路径和等），尝试用递归、迭代（栈/队列）、Morris遍历等多种方法实现。
扩展到N叉树和图：将二叉树的思维扩展到 N 叉树（LeetCode 589, 590），再扩展到图的深度优先搜索（DFS）和广度优先搜索（BFS）。你会发现，图的 DFS 就是树遍历的推广，只是需要多一个 visited 集合来避免环路。
连接其他领域：理解递归树如何用于分析递归算法的时间复杂度（如归并排序、快速排序）。理解回溯法本质上是在一棵隐式的“决策树”上进行深度优先搜索。

记住，面试官通过树题目，想考察的是你将复杂问题分解为可重复的子问题并系统解决的能力。当你再看到一道陌生的树题时，希望你的第一反应不再是慌乱，而是兴奋地开始启动这套思维框架：识别模式、定义递归、管理状态、合并结果。

把这套思维内化，你刷的每一道题才真正有了意义。