【代码随想录训练营】【Day 21】【二叉树-5】| Leetcode 513, 112, 106, 105

【代码随想录训练营】【Day 21】【二叉树-5】| Leetcode 513, 112, 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:
        if not root:
            return 0
        # que = collections.deque([root])
        # result = root.val

        # while que:
        #     size = len(que)
        #     for i in range(size):
        #         cur = que.popleft()
        #         if i == 0:
        #             result = cur.val
        #         if cur.left:
        #             que.append(cur.left)
        #         if cur.right:
        #             que.append(cur.right)
        # return result
        self.max_depth = float('-inf')
        self.result = None
        self.traversal(root, 1)
        return self.result
    def traversal(self, node, depth):
        if not node.left and not node.right:
            if depth > self.max_depth:
                self.result = node.val
                self.max_depth = depth
                return 
        if node.left:
            self.traversal(node.left, depth+1)
        if node.right:
            self.traversal(node.right, depth+1)
        return 

112. 路径总和

• 注意这是要返回值的回溯，注意返回值处的写法（有True就返回），以及root是先处理的

# 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 not root:
            return False

        def backtracking(node, path, targetSum):
            if not node.left and not node.right:
                if path == targetSum:
                    return True
                return False
            if node.left:
                path += node.left.val
                if backtracking(node.left, path, targetSum):
                    return True
                path -= node.left.val
            if node.right:
                path += node.right.val
                if backtracking(node.right, path, targetSum):
                    return True
                path -= node.right.val
            return False
        return backtracking(root, root.val, targetSum)  

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

• 先根据前序（后序）确定root，然后根据root.val 在中序中找到切割点，划分出左子树_中序、右子树_中序，再划分前序（后序），要点是前序的左右长度和中序的左右长度是一致的
  • 注意python 数组是左开右闭的

# 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 len(preorder) == 0:
            return None
        
        val = preorder[0]``
        index = inorder.index(val)
        root = TreeNode(val=val)

        leftInorder = inorder[:index]
        rightInorder = inorder[index+1:]
        leftPreorder = preorder[1: 1+index]
        rightPreorder = preorder[1+index: ]

        root.left = self.buildTree(leftPreorder, leftInorder)
        root.right = self.buildTree(rightPreorder, rightInorder)
        return root
        

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

• 先根据前序（后序）确定root，然后根据root.val 在中序中找到切割点，划分出左子树_中序、右子树_中序，再划分前序（后序），要点是前序的左右长度和中序的左右长度是一致的
  • 注意python 数组是左开右闭的

# 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 len(inorder) == 0:
            return None
        val = postorder[-1]
        root = TreeNode(val = val)
        index = inorder.index(val)

        leftInorder = inorder[: index]
        rightInoder = inorder[index+1:]
        leftPostorder = postorder[: index]
        rightPostorder = postorder[index: -1]

        root.left = self.buildTree(leftInorder, leftPostorder)
        root.right = self.buildTree(rightInoder, rightPostorder)

        return root