1. 寻找树的左下角
1)递归+回溯+栈:这里右侧叶子先入栈,出栈时就是从左叶子开始。若后出栈的(靠右的)叶子具有更大的深度,就用它更新当前结果。
class Solution:
def reachLeaf(self, node, depth, leaves):
if not node.right and not node.left:
leaves.append((node.val, depth))
if node.right:
self.reachLeaf(node.right, depth + 1, leaves)
if node.left:
self.reachLeaf(node.left, depth + 1, leaves)
def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
leaves = []
self.reachLeaf(root, 1, leaves)
max_d = 0
res = root.val
while leaves:
leaf = leaves.pop()
val, depth = leaf[0], leaf[1]
if max_d < depth:
max_d = depth
res = val
return res
也可以不用栈而使用两个全局变量,self.res保存当前结果,self.depth保存当前结果对应的深度。注意此时需要先进入左树。
class Solution:
def func(self, node, depth):
if not node.left and not node.right:
if self.depth < depth:
self.depth = depth
self.res = node.val
return
if node.left:
self.func(node.left, depth + 1)
if node.right:
self.func(node.right, depth + 1)
def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
self.res = root.val
self.depth = 0
self.func(root, 1)
return self.res
2)层序遍历:用一个嵌套列表保存每层的节点,遍历结束后取最后一层的第一个(最左)节点即可。
class Solution:
def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
from collections import deque
que = deque([root])
nodes = []
while que:
size = len(que)
tmp = []
for _ in range(size):
node = que.popleft()
tmp.append(node)
if node.left:
que.append(node.left)
if node.right:
que.append(node.right)
nodes.append(tmp)
return nodes[-1][0].val
2. 路径总和
递归:辅助函数func(),不对其传入空节点。参数为:node,当前节点;cur:当前节点之前的路径和;tar:目标和。若当前节点为叶子节点而且节点值+cur等于tar,则找到正确的路径,返回true;若为叶子但和不等于tar,则返回false。若不为叶子,继续遍历非空的孩子。若左子树返回结果为true,不用再考虑右子树,直接返回true;否则再接着判断右子树是否存在正确路径。
class Solution:
def func(self, node, cur, tar):
if not node.left and not node.right:
if node.val + cur == tar:
return True
return False #not this path
if node.left:
f1 = self.func(node.left, cur+node.val, tar)
else:
f1 = False
if f1:
return True #剪枝
if node.right:
f2 = self.func(node.right, cur+node.val, tar)
else:
f2 = False
return f1 or f2
def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
if not root:
return False
return self.func(root, 0, targetSum)
更简洁的写法 :
class Solution:
def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
if not root:
return False
if not root.left and not root.right and root.val == targetSum:
return True
return self.hasPathSum(root.left, targetSum-root.val) or self.hasPathSum(root.right, targetSum-root.val)
* 注意列表path不可以直接放入列表res,需要先将其转为不可变的tuple;
* 回溯包括cur和path,注意两者的回溯是如何实现的;
* 需要理清楚传入辅助函数func()的node、cur、path的关系,在这里cur和path是包含当前node的路径和、路径。
class Solution:
def func(self, node, cur, tar, path, res):
if not node.left and not node.right:
if cur == tar:
res.append(tuple(path)) #若不转为tuple,res会随着path回溯而变化。
return #到了叶子表面该路径结束,不管该路径是否符合要求,都返回。
if node.left:
path.append(node.left.val)
self.func(node.left, cur+node.left.val, tar, path, res)
path.pop()
if node.right:
path.append(node.right.val)
self.func(node.right, cur+node.right.val, tar, path, res)
path.pop()
def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
if not root:
return []
path = [root.val]
res = []
self.func(root, root.val, targetSum, path, res)
return res
3. 构造二叉树
106. 从中序与后序遍历序列构造二叉树 - 力扣(LeetCode)
左闭右开,记得每次除掉root。
class Solution:
def func(self, inorder, postorder, in_b, in_e, post_b, post_e):
if in_b == in_e:
return None
if in_b + 1 == in_e:
return TreeNode(val=inorder[in_b])
root_val = postorder[post_e-1]
root_id = inorder.index(root_val)
left_in_b, left_in_e = in_b, root_id
right_in_b, right_in_e = root_id+1, in_e
left_post_b, left_post_e = post_b, post_b + (root_id - in_b)
right_post_b, right_post_e = left_post_e, post_e - 1
root = TreeNode(val = root_val)
root.left = self.func(inorder, postorder, left_in_b, left_in_e, left_post_b, left_post_e)
root.right = self.func(inorder, postorder, right_in_b, right_in_e, right_post_b, right_post_e)
return root
def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
if not inorder:
return None
size = len(inorder)
return self.func(inorder, postorder, in_b=0, in_e=size, post_b=0, post_e=size)
105. 从前序与中序遍历序列构造二叉树 - 力扣(LeetCode)
class Solution:
def func(self, preorder, inorder, pre_b, pre_e, in_b, in_e):
if pre_b == pre_e:
return None
if pre_b + 1 == pre_e:
return TreeNode(val = preorder[pre_b])
root_val = preorder[pre_b]
root_id = inorder.index(root_val)
left_in_b, left_in_e = in_b, root_id
right_in_b, right_in_e = root_id + 1, in_e
left_pre_b, left_pre_e = pre_b + 1, pre_b + 1 + (root_id - in_b)
right_pre_b, right_pre_e = left_pre_e, pre_e
root = TreeNode(val = root_val)
root.left = self.func(preorder, inorder, left_pre_b, left_pre_e, left_in_b, left_in_e)
root.right = self.func(preorder, inorder, right_pre_b, right_pre_e, right_in_b, right_in_e)
return root
def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
if not preorder:
return None
return self.func(preorder, inorder, 0, len(preorder), 0, len(inorder))
思路与上题类似。这里仍用左闭右开。
class Solution:
def func(self, nums, begin, end):
if begin == end:
return None
root_val = max(nums[begin:end])
root_id = nums.index(root_val)
root = TreeNode(val = root_val)
root.left = self.func(nums, begin, root_id)
root.right = self.func(nums, root_id+1, end)
return root
def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
if not nums:
return None
return self.func(nums, 0, len(nums))