第十八天|二叉树

今天的题逻辑性比较强,需要仔细地思考才能进行整体的化简

513. Find Bottom Left Tree Value

这道题其实dfs和bfs都可以用,但是明显bfs更加的简单,因为是找最左下的元素即最后一层的最左边的元素

Way1:

用bfs遍历,每层的第一个元素都存下来,并且最后一次的元素为最终值

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

112. Path Sum

这道题相对来说简单一些,因为只需要判断是不是存在这样的path,并没说要把所有的path都输出戳来,所以只要做dfs(前中后序都可)就行

Way1:

传递的值有两个.一个是当前的remianing=sum-node.val,还有一个就是node的子节点

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        def dfs(node,remain):
            if not node:
                return
            if not node.left and not node.right:
                if remain==node.val:
                    return True
                else:
                    return False
            return dfs(node.left,remain-node.val) or dfs(node.right,remain-node.val)
        return dfs(root,targetSum)

113. Path Sum II

这道题相对于上面那道题相比需要进行traceback,并且要注意的是尽量不要把list作为一个参数进行传递,会很难控制

Way1:

传递的参数和上一题是一样的,多的步骤就是再判断是否有左右子树的时候进行遍历,且遍历后要还原remaining的值

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        res=[]
        if not root: 
            return []
        def dfs(node,remain):
            if not node.left and not node.right:
                if remain==0:
                    res.append(tmp[:])
                return
            if node.left:
                tmp.append(node.left.val)
                dfs(node.left,remain-node.left.val)
                tmp.pop()
            if node.right:
                tmp.append(node.right.val)
                dfs(node.right,remain-node.right.val)
                tmp.pop()
        tmp=[]
        tmp.append(root.val)
        dfs(root,targetSum-root.val)
        return res

105. Construct Binary Tree from Preorder and Inorder Traversal

这道题相对逻辑要复杂一些,要搞清楚如果对preorder和inorder进行切割

Way1:

直接调用当前的函数进行分割,不断的把preorder的第一个元素pop出来

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        if inorder:
            INDEX=inorder.index(preorder.pop(0))
            root=TreeNode(inorder[INDEX])
            root.left=self.buildTree(preorder,inorder[:INDEX])
            root.right=self.buildTree(preorder,inorder[INDEX+1:])
            return root

106. Construct Binary Tree from Inorder and Postorder Traversal

这道题思路上和上一题是一样的

Way1:
重建postorder和inder, inorder通过当前新建的node值找到对应的index划分左右子树.postorder通过inorder划分的左右子树的长度划分新的postorder,然后用递归建立node的左右子树

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        if not postorder:
            return
        root_val = postorder[-1]
        root = TreeNode(root_val)
        root_index = inorder.index(root_val)

        left_inorder = inorder[:root_index]
        right_inorder = inorder[root_index + 1:]

        left_postorder = postorder[:len(left_inorder)]
        right_postorder = postorder[len(left_inorder): len(postorder) - 1]

        root.left = self.buildTree(left_inorder, left_postorder)
        root.right = self.buildTree(right_inorder, right_postorder)

        return root

Way2:

这种方法更加巧妙. 需要想清楚的就是postorder是从后往前找的,所以子树的建立要先递归右再左

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        if inorder:
            INDEX=inorder.index(postorder.pop())
            node=TreeNode(inorder[INDEX])
            node.right=self.buildTree(inorder[INDEX+1:],postorder)
            node.left=self.buildTree(inorder[:INDEX],postorder)
            return node