此博客为《代码随想录》二叉树章节的学习笔记，主要内容为二叉树的属性相关的题目解析。
文章目录
- 101. 对称二叉树
- 104.二叉树的最大深度
- 111.二叉树的最小深度
- 222.完全二叉树的节点个数
- 110.平衡二叉树
- 257. 二叉树的所有路径
- 404.左叶子之和
- 513.找树左下角的值
- 112. 路径总和
101. 对称二叉树
题目链接
class Solution:
def isSymmetric(self, root: Optional[TreeNode]) -> bool:
def traversal(L, R):
if not L and not R:
return True
if not L or not R or L.val != R.val:
return False
return traversal(L.left, R.right) and traversal(L.right, R.left)
return not root or traversal(root.left, root.right)
- 递归时，需要判断
L和R两个节点，因此不能直接使用题目所给的函数（只有一个参数），而需另外创建traversal(L, R) - 分别递归
(L.left, R.right)和(L.right, R.left)
104.二叉树的最大深度
题目链接
class Solution:
def maxDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
- 深度优先遍历算法：后序遍历，因为需要先得到左、右子树的深度，才能够得到当前节点的深度；不用创建新的递归函数
- 广度优先遍历算法：见博客
111.二叉树的最小深度
题目链接
class Solution:
def minDepth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
if not root.left:
return self.minDepth(root.right) + 1
if not root.right:
return self.minDepth(root.left) + 1
return min(self.minDepth(root.left), self.minDepth(root.right)) + 1
- 深度优先遍历算法：后序遍历，但与上题不同，不能简单返回左右子树的
min，而需要特判左、右子树为空的情况；不用创建新的递归函数 - 广度优先遍历算法：见博客
222.完全二叉树的节点个数
题目链接
class Solution:
def countNodes(self, root: Optional[TreeNode]) -> int:
if root is None:
return 0
# 判断当前以当前节点为根结点的子树是否为满二叉树
leftHeight, rightHeight = 0, 0
leftPtr, rightPtr = root.left, root.right
while leftPtr:
leftPtr = leftPtr.left
leftHeight += 1
while rightPtr:
rightPtr = rightPtr.right
rightHeight += 1
if leftHeight == rightHeight:
return pow(2, leftHeight + 1) - 1
return self.countNodes(root.left) + self.countNodes(root.right) + 1
- 满二叉树节点数计算公式： 2 h − 1 2^{h}-1 2h−1
- 判断是否为满二叉树的方式：左指针一直向左指，右指针一直向右指，如果两侧深度一样，则为满二叉树
110.平衡二叉树
题目链接
class Solution:
def isBalanced(self, root: Optional[TreeNode]) -> bool:
def traversal(node: Optional[TreeNode]) -> int:
if node is None:
return 0
left = traversal(node.left)
if left == -1:
return -1
right = traversal(node.right)
if right == -1:
return -1
if abs(left - right) <= 1:
return max(left, right) + 1
else:
return -1
return traversal(root) != -1
- 后序遍历+剪枝，剪枝操作通过特定的函数返回值来实现
- 如果左右子树高度差已经超过 1，则函数返回 -1；否则，正常返回子树高度
257. 二叉树的所有路径
题目链接
class Solution:
def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
path, res = [], []
def traversal(node: Optional[TreeNode]) -> None:
if node is None:
return
path.append(str(node.val))
if not node.left and not node.right:
res.append('->'.join(path))
else:
traversal(node.left)
traversal(node.right)
path.pop()
traversal(root)
return res
- 先序遍历，先把当前节点放入 path，之后递归处理左右节点
- 不能在
if node is None:判断内部收集答案（会重复收集），而应该在叶子节点的位置收集
404.左叶子之和
题目链接
class Solution:
def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
res = 0
def traversal(node: Optional[TreeNode]):
nonlocal res
if node is None:
return
if node.left and not node.left.left and not node.left.right:
res += node.left.val
traversal(node.left)
traversal(node.right)
traversal(root)
return res
- 判断左叶子的逻辑需要在左叶子结点的上一层
nonlocal表示外部嵌套函数内的局部变量变量
513.找树左下角的值
题目链接
class Solution:
def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
maxDepth, res = 0, 0
def traversal(node: Optional[TreeNode], depth: int):
nonlocal maxDepth, res
if node is None:
return
traversal(node.left, depth + 1)
if depth > maxDepth:
maxDepth = depth
res = node.val
traversal(node.right, depth + 1)
traversal(root, 1)
return res
- 深度优先遍历：中序或后序遍历均可（要保证第一个访问的是"左"），之后正常遍历整棵树，并记录目前最大深度；左下角节点肯定为第一个到达最大深度的节点
- 层序遍历：遍历到最后一层找最左侧节点（更直观）
112. 路径总和
题目链接
class Solution:
def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
if root is None:
return False
targetSum -= root.val
if not root.left and not root.right:
return targetSum == 0
return self.hasPathSum(root.left, targetSum) or self.hasPathSum(root.right, targetSum)
- 到达叶节点时，判断
targetSum == 0
