18天【代码随想录算法训练营34期】● 513.找树左下角的值 ● 112. 路径总和 113.路径总和ii ● 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

513.找树左下角的值

# 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:
        q_ = []
        result = []
        if root:
            q_.append(root)
        while q_:
            lyr = []
            for i in range(len(q_)):
                temp = q_.pop(0)
                lyr.append(temp)
                if temp.left:
                    q_.append(temp.left)
                if temp.right:
                    q_.append(temp.right)
            result.append(lyr)
        return result[-1][0].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 findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        self.result = None
        self.max_depth = float('-inf')
        self.traversal(root, 0)
        return self.result
    def traversal(self, node, depth):
        if node.left is None and node.right is None:
            if depth > self.max_depth:
                self.max_depth = depth
                self.result = node.val
            return
        else:
            if node.left:
                self.traversal(node.left, depth+1)
            if node.right:
                self.traversal(node.right, depth+1)

112. 路径总和

# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root is None:
            return False
        if root.left is None and root.right is None and root.val == targetSum:
            return True
        else:
            leftSum = self.hasPathSum(root.left, targetSum - root.val)
            rightSum = self.hasPathSum(root.right, targetSum - root.val)
            return leftSum or rightSum

113.路径总和ii

106.从中序与后序遍历序列构造二叉树

# 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_left = inorder[:separator_idx]
        inorder_right = inorder[separator_idx + 1:]
        postorder_left = postorder[:len(inorder_left)]
        postorder_right = postorder[len(inorder_left):-1]

        left_node = self.buildTree(inorder_left, postorder_left)
        right_node = self.buildTree(inorder_right, postorder_right)

        root.left = left_node
        root.right = right_node
        
        return root

105.从前序与中序遍历序列构造二叉树

# 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, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if not preorder:
            return None

        root_val = preorder[0]
        root = TreeNode(root_val)

        separate_index = inorder.index(root_val)

        inorder_left = inorder[:separate_index]
        inorder_right = inorder[separate_index+1:]

        preorder_left = preorder[1:len(inorder_left)+1]
        preorder_right = preorder[len(inorder_left)+1:]

        root.left = self.buildTree(preorder_left, inorder_left)
        root.right = self.buildTree(preorder_right, inorder_right)

        return root