代码随想录算法训练营第十八天 | 513.找树左下角的值 112. 路径总和 113.路径总和ii 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

513. 找树左下角的值

代码：

# 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:
        result = []
        if root == None:
            return 0
        que = deque([root])
        while que:
            arr = []
            size = len(que)
            for i in range(size):
                node = que.popleft()
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                arr.append(node.val)
            result.append(arr)
        return result[-1][0]

112. 路径总和

思路：遍历顺序都可以

递归法：1.确定返回值和传入参数：bool类型，传入root，和计数器count（直接传入目标值，遇到一个节点就做一个减法）

2.终止条件：遇到叶子结点就结束

3.递归逻辑：需要加上回溯，因为如果没有找到符合条件的路径，回退的时候要把原删减的数值加回去，才能回到根节点的count数值继续换一条路径向下遍历

代码：

# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        def traversal(node: Optional[TreeNode], count: int):
            if not node.left and not node.right and count == 0:
                return True
            if not node.left and not node.right:
                return False
            if node.left:
                count -= node.left.val
                if traversal(node.left, count):
                    return True 
                count += node.left.val
            if node.right:
                count -= node.right.val
                if traversal(node.right, count):
                    return True
                count += node.right.val
            return False
        if root == None:
            return False
        return traversal(root, targetSum - root.val)

注意事项：最后传入参数要把根节点的值减去，因为在函数中没有减去根节点的处理

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 pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        result = []
        path = []
        def traversal(node, count):
            if not node.left and not node.right and count == 0:
                result.append(path[:])
                return
            if not node.left and not node.right:
                return
            if node.left:
                path.append(node.left.val)
                count -= node.left.val
                traversal(node.left, count)
                count += node.left.val
                path.pop()
            if node.right:
                path.append(node.right.val)
                count -= node.right.val
                traversal(node.right, count)
                count += node.right.val
                path.pop()
            return
        if root:
            path.append(root.val)
            traversal(root, targetSum - root.val)
        return result

注意事项：加入path的时候要把所有元素加进来

问题：result.append(path)为什么不可以？一个是引用，一个是拷贝数据进去

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

思路：

1.后序数组为0，空节点

2.后序数组最后一个元素为根节点

3.寻找中序数组该元素的位置作为切割点

4.切中序数组

5.切后序数组

6.递归处理左区间和右区间

代码：

# 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 len(postorder) == 0:
            return None
        rootval = postorder[-1]
        root = TreeNode(rootval)
        idx = inorder.index(rootval)
        leftinorder = inorder[:idx]
        rightinorder = inorder[idx + 1:]
        leftsize = len(leftinorder)
        rightsize = len(rightinorder)
        leftpostorder = postorder[:leftsize]
        rightpostorder = postorder[leftsize:len(postorder) - 1]
        root.left = self.buildTree(leftinorder, leftpostorder)
        root.right = self.buildTree(rightinorder, rightpostorder)
        return root
        

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

代码：

# 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, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if preorder == []:
            return None
        rootval = preorder[0]
        root = TreeNode(rootval)
        idx = inorder.index(rootval)
        leftinorder = inorder[:idx]
        rightinorder = inorder[idx + 1:]
        leftpreorder = preorder[1:1 + len(leftinorder)]
        rightpreorder = preorder[1 + len(leftinorder):]
        root.left = self.buildTree(leftpreorder, leftinorder)
        root.right = self.buildTree(rightpreorder, rightinorder)
        return root