D18|最左下角的值+路径总和+构造二叉树

树左下角的值

1.题目
给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。假设二叉树中至少有一个节点。
找树左下角的值
2.实现
想清楚左下角节点的特点

# 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:
    from collections import deque
    def __init__(self):
        self.maxdepth = 0
        self.res = 0

    def findbottom(self, root, depth):
        if not root:
            return
        if self.maxdepth < depth:
            self.maxdepth = depth
            self.res = root.val
        self.findbottom(root.left, depth + 1)
        self.findbottom(root.right, depth + 1)

    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        # 层次遍历，返回最后一组的第一个元素
        # 递归：后序遍历（左右根）+深度记录  深度变大时的第一个值
        depth = 1
        self.findbottom(root, depth)
        return self.res
        # q = deque()
        # res = []
        # q.append(root)
        # while q:
        #     size = len(q)
        #     tmp = []
        #     for _ in range(size):
        #         root = q.popleft()
        #         tmp.append(root.val)
        #         if root.left:
        #             q.append(root.left)
        #         if root.right:
        #             q.append(root.right)
        #     res.append(tmp)
        # return res[-1][0]

3.文章讲解

路径总和

1.题目
1）给二叉树的根节点 root 和一个表示目标和的整数 targetSum。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标targetSum 。如果存在，返回 true ；否则，返回 false 。
112. 路径总和
2）给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
113. 路径总和 II

2.复习前
1）注意两者返回不同的类型，如何去写返回值呢？
2）如果没有把握确实都可以新建函数，传入全局变量，但这种写法和习惯不太好~

3.实现
112. 路径总和

# 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 __init__(self):
        self.res = False

    def findpath(self, root, cursum, targetSum):
        if self.res:
            return
        cursum += root.val
        if not root.left and not root.right:
            if cursum == targetSum:
                self.res = True
            return
        if root.left:
            self.findpath(root.left, cursum, targetSum)
        if root.right:
            self.findpath(root.right, cursum, targetSum)

    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        # 寻找路径，则是根左右的前序遍历，再判断总和返回
        # 可以直接返回bool值，对targetSum--
        if not root:
            return False
        cursum = 0
        self.findpath(root, cursum, targetSum)
        return self.res

113. 路径总和 II

# 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 __init__(self):
        self.res = []

    def findpath(self, root, cursum, tmp, targetSum):
        cursum += root.val
        tmp.append(root.val)
        if not root.left and not root.right:
            if cursum == targetSum:
                # self.res.append(tuple(tmp))
                self.res.append(tmp[:])  # 如直接加入tmp，则后序对tmp的变化也会影响res，可以以切片形式复制进来
            return
        if root.left:
            self.findpath(root.left, cursum, tmp, targetSum)
            tmp.pop()
        if root.right:
            self.findpath(root.right, cursum, tmp, targetSum)
            tmp.pop()

    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        if not root:
            return []
        cursum = 0
        tmp = []
        self.findpath(root, cursum, tmp, targetSum)
        # for i in range(len(self.res)):
        #     self.res[i] = list(self.res[i])  
        return self.res

注意这里返回的数组！拷贝最安全
3.文章讲解
总结：如何确定返回值的类型
1）如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。
2）如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）
3）如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。

构造二叉树

1.题目
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。
106. 从中序与后序遍历序列构造二叉树
相关题目：105. 从前序与中序遍历序列构造二叉树
2.实现
只要明白怎么去切分两个遍历的数组即可

# 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, postorder, inorder):
        if len(postorder) == 0:
            return None
        val = postorder[-1]
        root = TreeNode(val)
        index = 0
        for i in range(len(inorder)):
            if inorder[i] == val:
                index = i
                break
        rlength = len(inorder) - i - 1
        root.left = self.buildtree(postorder[:i], inorder[:i])  # 左子树总是从0开始
        root.right = self.buildtree(postorder[i:rlength + i], inorder[i+1:])
        return root

    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        # 通过后序找根，中序区分左子树和右子树（每个值不同则进行遍历），再根据中序子树的大小划分后序的左右子树，直到后序长度为0
        return self.buildtree(postorder, inorder)

3.文章讲解