DAY18 代码随想录算法训练营 二叉树part05

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:
        if not root:return 0
        stack = [root]
        res = 0
        while stack:
            node = stack.pop()
            if node.left:
                stack.append(node.left)
            elif node.right:
                stack.append(node.right)
            else:
                res = node.val
        return res

解答错误，当输入为[1,2,3,4,null,5,6,null,null,7]时输出错误。
错误原因在于我理解题意有偏差，要求找到最底层最左边的节点，则说明首先考虑最底层再考虑最左边，因此等同于最底层的第一个节点。我的思路找到的是最左节点，并非最底层。

BFS

使用广度优先搜索的思路，分层搜索。

# 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:
        queue,ans = deque([root]),None
        while queue:
            ans = queue[0].val
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return ans

DFS

按照先左后右的顺序去遍历子树，最先搜索到的最深的节点即所求的节点。

# 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:
        ans,d = 0,0

        def dfs(root,deep):
            if root:
                nonlocal ans,d
                if deep>d:
                    ans,d = root.val,deep
                if root.left:
                    dfs(root.left,deep+1)
                if root.right:
                    dfs(root.right,deep+1)
        dfs(root,1)
        return ans

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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        # 若二叉树为空树则返回False
        if not root:return False
        queue = [(root,root.val)]
        while queue:
            node, path = queue.pop()
            if not node.left and not node.right and path == targetSum:
                return True
            if node.left:
                queue.append((node.left,path+node.left.val))
            if node.right:
                queue.append((node.right,path+node.right.val))
        return False

DFS

# 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:
        if not root:return False
        if not root.left and not root.right:
            return targetSum == root.val

        return self.hasPathSum(root.left,targetSum-root.val) or self.hasPathSum(root.right,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]]:
        res = []
        path = []

        def recur(root,tar):
            if not root:return
            path.append(root.val)
            tar -= root.val
            if tar == 0 and not root.left and not root.right:
                res.append(list(path))
            recur(root.left,tar)
            recur(root.right,tar)
            path.pop()
        recur(root,targetSum)
        return res

# 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]]:
        res = []
        que = deque()
        que.append((root, [], 0)) # 将要处理的节点，路径，路径和
        while que:
            node, path, pathSum = que.popleft()
            if not node: # 如果是空节点，不处理
                continue
            if not node.left and not node.right: # 如果是叶子节点
                if node.val + pathSum == targetSum: # 加上叶子节点后，路径和等于sum
                    res.append(path + [node.val]) # 保存路径
            # 处理左子树
            que.append((node.left, path + [node.val], pathSum + node.val))
            # 处理右子树
            que.append((node.right, path + [node.val], pathSum + node.val))
        return res

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

# 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]:
        # 中序:左中右 后序:左右中
        # 若中序和后序都为空 return None
        if not inorder or not postorder:
            return None
        rootval = postorder[-1]
        root = TreeNode(rootval)
        # 首先找出根节点在中序遍历中的位置
        midindex = inorder.index(rootval)
        # 中序遍历的左子树右子树
        inleft = inorder[:midindex]
        inright = inorder[midindex+1:]
        # 后序遍历的左子树右子树
        postleft = postorder[:len(inleft)]
        postright = postorder[len(inleft):len(inorder)-1]

        root.left = self.buildTree(inleft,postleft)
        root.right = self.buildTree(inright,postright)

        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 not preorder or not inorder:
            return None
        rootval = preorder[0]
        root = TreeNode(rootval)

        midindex = inorder.index(rootval)

        inleft = inorder[:midindex]
        inright = inorder[midindex+1:]

        preleft = preorder[1:len(inleft)+1]
        preright = preorder[len(inleft)+1:]

        root.left = self.buildTree(preleft,inleft)
        root.right = self.buildTree(preright,inright)

        return root