算法训练 Day18

513.找树左下角的值

解法1：迭代

# D# 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:
        # method 1
        if not root:
            return 0
        queue = [root]
        while queue:
            node = queue.pop(0)
            if node.right:
                queue.append(node.right)
            if node.left:
                queue.append(node.left)
            res = node.val
        return res

解法2：递归

  

# 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:
        # method 2
        max_depth = -inf
        res = 0

        def dfs(root,depth):
            if not root:
                return None
            nonlocal res
            nonlocal max_depth
            if not root.left and not root.right:
                if depth > max_depth:
                    max_depth = depth
                    res = root.val
            
            if root.left:
                dfs(root.left,depth+1)
            if root.right:
                dfs(root.right,depth+1)
        
        dfs(root,0)
        return res

112. 路径总和

解法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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        # method 1
        if not root:
            return False
        total = [root.val]
        queue = [root]
        while queue:
            value = total.pop(0)
            node = queue.pop(0)
            if not node.left and not node.right and value == targetSum:
                return True
            
            if node.left:
                queue.append(node.left)
                total.append(value + node.left.val)
            
            if node.right:
                queue.append(node.right)
                total.append(value+node.right.val)
        return False

解法2：递归

# 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:
        # method 2
        if not root:
            return False
        if not root.left and not root.right:
            return root.val == targetSum
        return self.hasPathSum(root.left,targetSum-root.val) or self.hasPathSum(root.right,targetSum-root.val)

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

解法：在中序和后序遍历之间寻找规律

• 第一步：如果数组大小为零的话，说明是空节点了，返回 None。

• 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

• 第三步：找到后序数组最后一个元素在中序数组的位置，作为index

• 第四步：按着index切割中序数组，切成中序左数组和中序右数组 

• 第五步：按着左中序的大小切割后序数组，切成后序左数组和后序右数组

• 第六步：递归处理左区间和右区间

# 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 inorder or not postorder:
            return None


        # 第二步: 后序遍历的最后一个就是当前的中间节点.
        node = postorder.pop()
        root = TreeNode(node) 

        # 第三步: 找切割点.
        indx = inorder.index(node)

        # 第四步: 切割inorder数组. 得到inorder数组的左,右半边. 
        in_left = inorder[:indx]
        in_right = inorder[indx+1:]

        # 第五步: 切割postorder数组. 得到postorder数组的左,右半边.
        # ⭐️ 重点1: 中序数组大小一定跟后序数组大小是相同的. 
        post_left = postorder[:len(in_left)]
        post_right = postorder[len(in_left):]

        # 第六步: 递归
        root.left = self.buildTree(in_left,post_left)
        root.right = self.buildTree(in_right,post_right)
        return root