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

513. 找树左下角的值

leetcode 513. 找树左下角的值
代码随想录

层次遍历，优化了之前的两个队列的方式，一个队列+节点数量，进入下一层时当前队列的数量就是这一层的节点数。
两次访存变成一次访存，时间能进步这么多？python执行环节感觉有问题

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        queue = deque()
        queue.append(root)
        res = 0
        while len(queue)!=0:
            queueLen = len(queue)
            for i in range(queueLen):
                temp = queue.popleft()
                if i == 0:
                    # res = queue[0].val
                    res = temp.val
                # temp = queue.popleft()
                if temp.left:
                    queue.append(temp.left)
                if temp.right:
                    queue.append(temp.right)
        return res

112. 路径总和

leetcode 112. 路径总和
代码随想录

回溯法
但是一开始总是没办法正确的返回是否有路径，值的计算也总是错了。看了carl哥的解析之后明白了，什么时候该进入下一层和回溯（sum-=node.val）;需要把逻辑搞清楚。
113题的路径总和就是要注意使用copy（python）

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        Flag = False
        if root == None:
            return False
        sum = root.val
        path = []
        def traverse(root, targetSum, sum, Flag):
            if not root:
                return False
            if root.left == None and root.right == None:
                if sum == targetSum:
                    return True
            if root.left:
                sum += root.left.val
                if traverse(root.left, targetSum, sum, Flag):
                    return True
                sum -= root.left.val
            if root.right:
                sum += root.right.val
                if traverse(root.right, targetSum, sum, Flag):
                    return True
                sum -= root.right.val
            return False
        traverse(root,targetSum,sum, Flag)
        return traverse(root,targetSum,sum, Flag)

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

leetcode 106. 从中序与后序遍历序列构造二叉树
代码随想录

这里的解法换到前序和中叙上就不行了，需要记录下标。

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        def constrcut(inorder, postorder):
            if len(inorder) == 0:
                return None
            privot = postorder[-1]
            node = TreeNode(privot)
            if len(inorder) == 1:
                return node
            # 寻找分界点
            index = 0
            for i in range(len(inorder)):
                if inorder[i] == privot:
                    index = i
            # 左右孩子 (左闭右开)
            node.left = constrcut(inorder[0:index],postorder[0:index]) 
            node.right = constrcut(inorder[index+1:],postorder[index:-1])
            return node
        return constrcut(inorder,postorder)