day18（二叉树）-py

第六章 二叉树 part05

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

代码随想录：代码随想录

今天题量真的爆炸

找树左下角的值

题意：给定一个二叉树，在树的最后一行找到最左边的值。

思路：我认为最重要的首先就是拆分题意，总结一下

1.最后一行说明是深度最大的部分取值，就是说要先找出深度最大处

2.就是判断深度后向左子树遍历

3.如何判断是左叶子

4.当发现用一个函数思路比较混乱，或者想要先执行一个其他操作的时候，可以多写几个函数。并且可以在给定要写函数中写self.xxx的参数，可以方便后续其他函数对其操作。

class Solution:
    def findBottomLeftValue(self, root: TreeNode) -> int:
        self.max_depth = 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:
            self.traversal(node.left, depth+1)
        if node.right:
            self.traversal(node.right, depth+1)

路径总和

有两题

题意1：给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

题意2：给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

思路：其实两题差不多，一个是判断是否有目标和路径，输出为bool型；一个是输出所有目标和路径，输出为列表。那无非第一个用判断即可，第二个可以用队列push和pop。都差不多，就只放第一个吧。

总结一下：

核心中的核心就是递归＋回溯的思路。回溯就是说我每往下找完，要回退，因为元素要多次利用。那思路很清晰，就是：有左右节点就继续递归，如果是叶子节点就判断是够等于目标值，对应输出bool型。

class Solution:
    def traversal(self, cur: TreeNode, count: int) -> bool:
        if not cur.left and not cur.right and count == 0: # 遇到叶子节点，并且计数为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: TreeNode, sum: int) -> bool:
        if root is None:
            return False
        return self.traversal(root, sum - root.val)    

从中序与后序（前序）遍历序列构造二叉树

中序＋前序 or 中序＋后序，思路相同，只放一个了

题意：根据一棵树的中序遍历与后序遍历构造二叉树。

抄一个总结，感觉很精髓：

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

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

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

• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）

• 第五步：切割后序数组，切成后序左数组和后序右数组

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

python是真方便，xxx.index（xxx）原来是可以直接找List的索引值，再也不用for循环找一边了。

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        # 第一步: 特殊情况讨论: 树为空. (递归终止条件)
        if not postorder:
            return None

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

        # 第三步: 找切割点.
        separator_idx = inorder.index(root_val)

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

        # 第五步: 切割postorder数组. 得到postorder数组的左,右半边.
        # ⭐️ 重点1: 中序数组大小一定跟后序数组大小是相同的.
        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