513.找树左下角的值
深度优先搜索(DFS)的方式来遍历二叉树,同时维护了最大深度和最左边叶子节点的值。
递归法+回溯
class Solution:
def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
self.max_depth = float('-inf')
self.result = None
self.tarvle(root, 0)
return self.result
def tarvle(self,cur,depth):
if not cur.left and not cur.right:
if depth>self.max_depth:
self.max_depth=depth
self.result=cur.val
return
if cur.left:
depth+=1
self.tarvle(cur.left,depth)
depth-=1
if cur.right:
depth+=1
self.tarvle(cur.right,depth)
depth-=1
递归法+回溯(精简版)
class Solution:
def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
self.max_depth = float('-inf')
self.result = None
self.traversal(root, 0)
return self.result
def traversal(self, node, depth):
if not node.left and not node.right:
if depth > self.max_depth:
self.max_depth = depth
self.result = node.val
return
if node.left:
self.traversal(node.left, depth+1)
if node.right:
self.traversal(node.right, depth+1)
(深度 depth 在不同层次之间增加和减少,以确保我们正确地跟踪节点所在的深度,而不会受到递归调用的深度影响。这种方式帮助我们在二叉树中正确导航并执行递归遍历。)
迭代方法(优先)
from collections import deque
class Solution:
def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
queue=collections.deque([root])
result=[]
while queue:
size=len(queue)
for i in range(size):
cur=queue.popleft()
if i==0:
result=cur.val
if cur.left:
queue.append(cur.left)
if cur.right:
queue.append(cur.right)
return result
112. 路径总和
递归法
# self.right = right
class Solution:
def tarevel(self,cur,count):
if not cur.left and not cur.right and count==0:
return True
if not cur.left and not cur.right:
return False
if cur.left:
count-=cur.left.val
if self.tarevel(cur.left,count):
return True
count+=cur.left.val
if cur.right:
count-=cur.right.val
if self.tarevel(cur.right,count):
return True
count+=cur.right.val
return False
def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
if not root:
return False
return self.tarevel(root,targetSum- root.val)
迭代先跳了
112. 路径总和II
class Solution:
def __init__(self):
self.result = []
self.path = []
def traversal(self, cur, count):
if not cur.left and not cur.right and count == 0:
self.result.append(self.path[:])
return
if not cur.left and not cur.right:
return
if cur.left:
self.path.append(cur.left.val)
count -= cur.left.val
self.traversal(cur.left, count)
count += cur.left.val
self.path.pop()
if cur.right:
self.path.append(cur.right.val)
count -= cur.right.val
self.traversal(cur.right, count)
count += cur.right.val
self.path.pop()
return
def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
self.result.clear()
self.path.clear()
if not root:
return self.result
self.path.append(root.val)
self.traversal(root, sum - root.val)
return self.result
106.从中序与后序遍历序列构造二叉树
递归
class Solution:
def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
if not postorder:
return None
root_val=postorder[-1]
root=TreeNode(root_val)
part_idx=inorder.index(root_val)
inorder_left=inorder[:part_idx]
inorder_right=inorder[part_idx+1:]
postorder_left = postorder[:len(inorder_left)]
postorder_right = postorder[len(inorder_left):len(postorder)-1]
root.left=self.buildTree(inorder_left,postorder_left)
root.right=self.buildTree(inorder_right,postorder_right)
return root
105.从前序与中序遍历序列构造二叉树
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
if not preorder:
return None
root_val=preorder[0]
root=TreeNode(root_val)
part_idx=inorder.index(root_val)
inorder_left = inorder[:part_idx]
inorder_right = inorder[part_idx + 1:]
preorder_left = preorder[1:1 + len(inorder_left)]
preorder_right = preorder[1 + len(inorder_left):]
root.left=self.buildTree(preorder_left,inorder_left)
root.right=self.buildTree(preorder_right,inorder_right)
return root