代码随想录一刷：补Day18

文章目录

• 前言

• 一、找树左下角的值

• 二、路径总和

• 三、从中序与后序遍历序列构造二叉树 

• 总结

---

前言

每日刷题，从我做起。

一、找树左下角的值

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
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:
            depth += 1
            self.traversal(node.left, depth)
            depth -= 1

        if node.right:
            depth += 1
            self.traversal(node.right, depth)
            depth -= 1

二、路径总和

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def traversal(self, cur: TreeNode, count:int) -> bool:
        if not cur.left and not cur.right and count == 0: #遇到叶子节点，且计数为0
            return True
        if not cur.left and not cur.right: #遇到叶子节点直接返回
            return False
        
        if cur.left:#左
            count -= cur.left.val
            if self.traversal(cur.left, count): #递归处理节点
                return True
            count += cur.left.val #回溯，撤销处理结果
        
        if cur.right:#右
            count -= cur.right.val
            if self.traversal(cur.right, count): #递归处理节点
                return True
            count += cur.right.val #回溯，撤销处理结果
        return False



    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root is None:
            return False
        return self.traversal(root, targetSum - root.val )

三、从中序与后序遍历序列构造二叉树 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
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)

        #第三步：找切割点
        separator_idx = inorder.index(root_val)
        
        #第四步：切割inorder数组，得到inorder左右半边
        inorder_left= inorder[:separator_idx]
        inorder_right = inorder[separator_idx + 1:]

        #第五步：切割postorder数组，得到inorder数组的左右半边
        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

---

总结

加油。