二叉树中递归的思想，在这本Leetbook中讲的很细了，这里不展开。下面是几道例题：

226. 翻转二叉树（剑指 Offer 27. 二叉树的镜像）

递归法前序遍历：

class Solution:def invertTree(self, root: TreeNode) -> TreeNode:if not root:returnroot.left, root.right = root.right, root.left    self.invertTree(root.left)self.invertTree(root.right)return root

迭代法前序遍历：

class Solution:def invertTree(self, root: TreeNode) -> TreeNode:if not root:return rootstack = []stack.append(root)while stack:node = stack.pop()if node:if node.right:stack.append(node.right)if node.left:stack.append(node.left)stack.append(node)stack.append(None)else:node = stack.pop()node.left, node.right = node.right, node.leftreturn root

递归法中序遍历（伪）：

class Solution:def invertTree(self, root: TreeNode) -> TreeNode:if not root:returnself.invertTree(root.left)root.left, root.right = root.right, root.left    self.invertTree(root.left)return root

迭代法中序遍历：

class Solution:def invertTree(self, root: TreeNode) -> TreeNode:if not root:return rootstack = []stack.append(root)while stack:node = stack.pop()if node:if node.right:stack.append(node.right)stack.append(node)stack.append(None)if node.left:stack.append(node.left)else:node = stack.pop()node.left, node.right = node.right, node.leftreturn root

递归法后序遍历：

class Solution:def invertTree(self, root: TreeNode) -> TreeNode:if not root:returnleft = self.invertTree(root.left)right = self.invertTree(root.right)root.left, root.right = right, leftreturn root

迭代法后序遍历：

class Solution:def invertTree(self, root: TreeNode) -> TreeNode:if not root:return rootstack = []stack.append(root)while stack:node = stack.pop()if node:stack.append(node)stack.append(None)if node.right:stack.append(node.right)if node.left:stack.append(node.left)else:node = stack.pop()node.left, node.right = node.right, node.leftreturn root

在遍历的过程中，把记录节点值这个操作改成交换左右子节点即可，前中后序遍历都是可以的，递归法和迭代法都行。唯一要注意的就是中序遍历，用递归法是左根左，因为使用递归的中序遍历，某些节点的左右孩子会翻转两次。甚至，层序遍历也是可以的，可以看我的这篇文章。

100. 相同的树

class Solution:def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:if (not p) and (not q):return Trueelif (not p) or (not q):return Falseelif p.val != q.val:return Falseelse:return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

判断两个二叉树是否相同，思路如下：两个二叉树是否同时为空？是否一个为空而另一个不为空？他们的根节点值是否相同？最后是递归的判断，他们的左右子树是否都相同？

101. 对称二叉树（剑指 Offer 28. 对称的二叉树）

class Solution:def isSymmetric(self, root: TreeNode) -> bool:return self.check(root, root)def check(self, p: TreeNode, q: TreeNode) -> bool:if (not p) and (not q):return Trueelif (not p) or (not q):return Falseelif p.val != q.val:return Falseelse:return self.check(p.left, q.right) and self.check(p.right, q.left)

判断一个二叉树是否为对称二叉树，可以转化为判断这个树和自己的镜像树是否相同。关键在于用 self.check(root, root) 构造出两个树，然后以相反方向进行递归和判断。

迭代写法的话使用的是队列，用栈或者数组等其他的容器都行，关键是把节点放入容器的顺序不能错，然后每次取两个左右对应位置的节点出来做比较，如下：

class Solution:def isSymmetric(self, root: TreeNode) -> bool:if not root:return Truequeue = collections.deque()queue.append(root.left)queue.append(root.right)while queue:leftNode = queue.popleft()rightNode = queue.popleft()if (not leftNode) and (not rightNode):continueelif (not leftNode) or (not rightNode):return Falseelif leftNode.val != rightNode.val:return Falseelse:queue.append(leftNode.left)queue.append(rightNode.right)queue.append(leftNode.right)queue.append(rightNode.left)return True

617. 合并二叉树

class Solution:def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:if not root1 and not root2:return Noneif not root1:return root2if not root2:return root1new_root = TreeNode(root1.val + root2.val)  # 新建节点new_root.left = self.mergeTrees(root1.left, root2.left)new_root.right = self.mergeTrees(root1.right, root2.right)return new_root

两个二叉树一起从根节点开始向下递归，如果其中一个二叉树的节点为空，则合并后的节点就是另一个二叉树的节点。合并后的二叉树每次都要新建节点，然后左右子树用递归得到。优化的写法是不新建节点，直接用其中一个二叉树的节点，只需要把另一个二叉树的节点值加过去即可。

class Solution:def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:if not root1 and not root2:return Noneif not root1:return root2if not root2:return root1root1.val += root2.val  # 用旧节点root1.left = self.mergeTrees(root1.left, root2.left)root1.right = self.mergeTrees(root1.right, root2.right)return root1

104. 二叉树的最大深度

class Solution:def maxDepth(self, root: TreeNode) -> int:if not root:return 0left_depth = self.maxDepth(root.left)right_depth = self.maxDepth(root.right)return max(left_depth, right_depth) + 1

自底向上的递归，在Leetbook中有详细介绍，简单来说：如果我们知道一个根节点，以其左子节点为根的最大深度为 left_depth 和以其右子节点为根的最大深度为 right_depth ，我们就可以选择它们之间的最大值，再加上1来获得根节点所在的子树的最大深度。

543. 二叉树的直径

class Solution:def diameterOfBinaryTree(self, root: TreeNode) -> int:self.ans = 1def depth(node: TreeNode):if not node:return 0left_depth = depth(node.left)right_depth = depth(node.right)# 此节点作为根节点的最大深度是否为众节点中最大，是则更新ansself.ans = max(self.ans, left_depth + right_depth + 1)return max(left_depth, right_depth) + 1depth(root)return self.ans - 1

虽然题目说明了直径（最大的两节点间路径）不一定经过根节点，但是归根到底，两节点间路径必然会有个根节点，目标就是找到把树中所有节点都作为根节点时，各自求出最大深度（上一题思路），然后在这些最大深度中找到最大的作为直径 ans。

563. 二叉树的坡度

class Solution:def findTilt(self, root: TreeNode) -> int:self.ans = 0def val_sum(node: TreeNode):if not node:return 0left_sum = val_sum(node.left)right_sum = val_sum(node.right)tilt = abs(left_sum - right_sum)self.ans += tiltreturn left_sum + right_sum + node.valval_sum(root)return self.ans

本题与最大深度类似，区别在于是记录深度之差的绝对值（坡度），然后递归返回左右子树和自身值之和。

112. 路径总和

class Solution:def hasPathSum(self, root: TreeNode, targetSum: int) -> bool:if not root: # 非节点return Falseif not root.left and not root.right:  # 叶子节点return targetSum == root.valreturn self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)

思路是如果子树的和等于 targetSum 减去当前节点的值，则存在路径。所以终止条件为非节点则返回 False，为叶子节点则返回 targetSum == 当前节点的值，函数调用是子节点和减去当前节点值后的 targetSum 。

113. 路径总和 II（剑指 Offer 34. 二叉树中和为某一值的路径）

class Solution:def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:ans = []path = []def dfs(root: TreeNode, targetSum: int):if not root:returnpath.append(root.val)targetSum -= root.valif not root.left and not root.right and targetSum == 0:ans.append(path.copy())dfs(root.left, targetSum)dfs(root.right, targetSum)path.pop()dfs(root, targetSum)return ans

这题不是求有没有路径，而是要把路径都找出来，答案放在列表 ans 里。同样还是递归地深度遍历，用一个 path 列表记录路径，如果是叶节点且和数符合条件，就往 ans 里面加入路径 path，否则就遍历左子树和右子树，记得递归的最后要把 path 进行弹出，然后注意往 ans 里面加入的是 path 的浅拷贝，可以写成 path.copy() 或者 path[:]

222. 完全二叉树的节点个数

class Solution:def countNodes(self, root: TreeNode) -> int:if not root:return 0left = root.leftright = root.right# 深度初始化为 0，是因为位运算中 2 << 0 == 2，2 << 1 == 4leftHeight = 0rightHeight = 0# 求左子树深度while left:left = left.leftleftHeight += 1# 求右子树深度while right:right = right.rightrightHeight += 1# 若为满二叉树，则节点数为 2 的 leftHeight 次方，用位运算求if leftHeight == rightHeight:return (2 << leftHeight) - 1return self.countNodes(root.left) + self.countNodes(root.right) + 1

这题用常规的前中后序遍历或者层序遍历都能做，但是这样就没利用到完全二叉树的性质了。完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

优化点就是用位运算代替指数运算。

236. 二叉树的最近公共祖先

class Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':def dfs(root: 'TreeNode', p: 'TreeNode', q: 'TreeNode'):# 如果当前节点为空，则说明 p、q 不在 node 的子树中，不可能为公共祖先，直接返回 Noneif not root:return None# 如果当前节点 root 等于 p 或者 q，那么 root 就是 p、q 的最近公共祖先，直接返回 rootif root == p or root == q:return root# 递归遍历左子树、右子树，并判断左右子树结果node_left = dfs(root.left, p, q)node_right = dfs(root.right, p, q)# 如果左右子树都不为空，则说明 p、q 在当前根节点的两侧，当前根节点就是他们的最近公共祖先if node_left and node_right:return rootelif node_left:return node_left:else:return node_rightans = dfs(root, p, q)return ans

简单概括，就是基于后序遍历，从下往上，在找到 p 或者 q 的时候就返回。这样当 p 和 q 在两边时，就会返回最近公共祖先；当 p 和 q 在同一条路径上时，就会返回两者中作为祖先的那个。