代码随想录算法训练营Day18|leetcode513 找树左下角的值、leetcode112 路经总和、leetcode106 从中序与后序遍历序列构造二叉树

leetcode513 找树左下角的值

题目链接：513. 找树左下角的值 - 力扣（LeetCode）

视频讲解：怎么找二叉树的左下角？ 递归中又带回溯了，怎么办？| LeetCode：513.找二叉树左下角的值_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

思路：找左下角的值就是最后一行最左侧得值，也就是深度最大的最左边。代码逻辑为最大深度初始化为int的最小值，方便比较，定义一个result记录当前最大深度结点的值，depth记录当前遍历的深度。定义一个函数，如果走到了叶子节点，对比此时的深度和最大深度，如果此时深度更大就更新最大深度并更新result里面的值，然后分别递归左右节点，递归函数后面要进行回溯，因为找完一条路之后要回去找另外一条路。

# 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')       #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

 leetcode112.路径总和

题目链接：112. 路径总和 - 力扣（LeetCode）

视频讲解：拿不准的遍历顺序，搞不清的回溯过程，我太难了！ | LeetCode：112. 路径总和_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

思路：设置一个计数器，初始值为目标值，每经过一个节点就减该节点的值，递归结束条件就是遇到叶子节点且计数器为0，返回true，否则遇到叶子节点返回false，单层条件就是如果节点的左孩子存在计数器就减左孩子的值，然后递归，递归完再把左孩子的值接回来，是回溯的过程，右节点同理。

# 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:
            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)

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

题目链接：106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

视频讲解：坑很多！来看看你掉过几次坑 | LeetCode：106.从中序与后序遍历序列构造二叉树_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

思路：后序遍历的最后一个元素是根节点，找到根节点就可以在中序遍历中区分出左区间和右区间，找到左区间和右区间就可以在后序遍历中找到左右区间的节点，循环往复就可以还原二叉树。递归结束的条件是后序数组为0了。

# 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)      #后序遍历的最后一个就是当前的中间节点

        seporator_idx = inorder.index(root_val)    #找切割点

        inorder_left = inorder[:seporator_idx]
        inorder_right = inorder[seporator_idx + 1:]    #切割inorder数组

        postorder_left = postorder[:len(inorder_left)]
        postorder_right = postorder[len(inorder_left):len(postorder) - 1]    #切割postorder数组

        root.left = self.buildTree(inorder_left, postorder_left)
        root.right = self.buildTree(inorder_right, postorder_right)

        return root