代码随想录 Day-18｜#513 找树左下角的值｜#112 路径总和 ｜#113 路径总和ii｜#106 从中序与后序遍历序列构造二叉树｜#105 从前序与中序遍历序列构造二叉树

清单

● 513.找树左下角的值
● 112. 路径总和 113.路径总和ii
● 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

LeetCode#513.找树左下角的值

1. 题目

给定一个二叉树的根节点 root，请找出该二叉树的最底层最左边节点的值。
假设二叉树中至少有一个节点。

2. 思路

遍历二叉树，记录每层第一个节点

3. 代码实现

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        if not root:
            return []
        
        queue = collections.deque([root])
        result = 0
        while queue:
            level_size = len(queue)
            for i in range(level_size):
                node = queue.popleft()
                if i == 0:
                    result = node.val
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return result

LeetCode#112 路径总和

1. 题目

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum。如果存在，返回 true；否则，返回 false。
叶子节点是指没有子节点的节点

2. 思路

遍历过程中，增加一个元素，用于记录遍历之和，当元素和等于targetSum时 return true，否则 return false

3. 代码实现

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False

        st = [(root,root.val)]
        while st:
            node,path_sum = st.pop()
            if not node.left and not node.right and path_sum == targetSum:
                return True
            if node.right:
                st.append((node.right, path_sum + node.right.val))
            if node.left:
                st.append((node.left, path_sum + node.left.val))
        return False

LeetCode#113 路径总和 ii

1. 题目

给你二叉树的根节点 root 和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点

2. 思路

同上一题思路一致，增添一个res用于存储满足条件路径

3. 代码实现

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        if not root:
            return []

        st = [(root,[root.val])]
        res = []
        while st:
            node, path = st.pop()
            if not node.left and not node.right and sum(path) == targetSum:
                res.append(path)
            if node.right:
                st.append((node.right, path + [node.right.val]))
            if node.left:
                st.append((node.left, path + [node.left.val]))
        return res

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

1. 题目

给定两个整数数组 inorder 和 postorder，其中 inorder 是二叉树的中序遍历，postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树

2. 思路

中序构成为左中右，后序构成为左右中，通过后序确定中值，根据中序确定左值，然后对后序进行切割，最后构成二叉树

3. 代码实现

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        if not postorder:
            return None
        
        #分割中值构建二叉树
        root_order = postorder[-1]
        root = TreeNode(root_order)

        #确定分割点
        seperator_point = inorder.index(root_order)

        #分割inorder
        inorder_left = inorder[:seperator_point]
        inorder_right = inorder[seperator_point + 1:]

        #分割postorder
        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

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

1. 题目

给定两个整数数组 preorder 和 inorder，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点

2. 思路

前序为中左右，中序为左中右，通过中序确定右支，通过前序确认中值

3. 代码实现

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if not preorder:
            return None
        
        #根节点
        root_order = preorder[0]
        root = TreeNode(root_order)

        #分割点
        separator_point = inorder.index(root_order)
        
        #分割inorder
        inorder_left = inorder[:separator_point]
        inorder_right = inorder[separator_point + 1:]

        #分割preoder
        preorder_left = preorder[1: 1 + len(inorder_left)]
        preorder_right = preorder[1 + len(inorder_left):]

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

        return root