代码随想录day18

简单，层序遍历

class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        que=collections.deque()
        que.append(root)
        res=0
        while que:
            size=len(que)

            for i in range(size):
                node=que.popleft()
                if i==0:
                    res=node.val
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
        return res

第二题

前序遍历，终止条件分两种：遍历到叶子节点--满足or不满足要求

思路：

if 左节点存在：（条件）

        count--left value（前序）

        if 递归函数  true （递归，true一层层传上去，不回溯）

        count+left value（回溯，配合下面false，不符合条件一直回溯）

if 右边节点存在：（条件）

        count--right value（前序）

        if 递归函数（递归）

        count+left value（回溯）

最终返回一个false（配合回溯算法，返回一个上一次if的判断结果，让回溯进行下去）

有递归必有回溯，即使递归在if里，递归也执行了，递归和回溯在同一顺序级别

如果递归反了ture，不执行回溯，函数直接一层层传上去，输出true

如果递归发了false，执行回溯，直接到头

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)      

第三题

注意事项：

1.递归终止条件（后序为空）

2.返回一个根节点，其值为后序最后一个

3.区间对应

本质上是从上到下结构

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