Day18 算法学习|二叉树05 继续递归/遍历构建二叉树

最新推荐文章于 2024-06-13 10:13:20 发布

Hola_error

最新推荐文章于 2024-06-13 10:13:20 发布

阅读量28

点赞数

文章标签：算法学习数据结构

本文链接：https://blog.csdn.net/m0_55811518/article/details/131194906

版权

题目 513.找树左下角的值

问题描述

给定一个二叉树，在树的最后一行找到最左边的值。
在这里插入图片描述

解题思路

因为要找最后一行最左边的值，所以先找最后一行，用深度搜索实现。

最左的话，前序，中序，后序都可以，因为这几个搜索左边都是最优先的.
如果最后一行只有一个右节点，此节点就为答案，因为我们找的是”最靠近左边的值”而不是单纯左边的值

代码

递归（比较抽象）


class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        self.maxDepth = -1
        self.res = 0
        self.dfs(root, 0)
        return self.res

    def dfs(self, node, depth):
        if node is None:
            return 
        if depth > self.maxDepth:
            self.maxDepth = depth
            self.res = node.val
        self.dfs(node.left, depth + 1)
        self.dfs(node.right, depth + 1)

迭代

from collections import deque
class Solution:
    def findBottomLeftValue(self, root):
        if root is None:
            return 0
        queue = deque()
        queue.append(root)
        result = 0
        while queue:
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                if i == 0:
                    result = node.val
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return result

复杂度分析（递归）

时间复杂度O(N)
空间复杂度

在最坏的情况下，二叉树可能退化成链表，也就是说，每个节点都只有一个孩子节点。这种情况下，递归的深度就等于二叉树的节点数，所以空间复杂度为O(N)。另一方面，如果二叉树是平衡的，那么递归的深度就等于二叉树的高度，即log(N)，所以空间复杂度为O(log(N))。

题目 112. 路径总和

问题描述

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。
在这里插入图片描述

解题思路

这个问题是要确定是否存在一条从根到叶的路径，这条路径上所有节点的值相加等于给定的目标和。

确定递归函数的参数和返回值：在这个问题中，我们需要构造一个辅助函数，用于实现深度优先搜索（DFS）。这个函数的参数应该包括当前节点和剩余的目标和（count），并返回一个布尔值，表示是否存在满足条件的路径。
确定终止条件：在递归函数中，我们需要确定一些终止条件。如果当前节点为空，那么直接返回False，因为空节点不能构成任何路径。如果当前节点是叶子节点（即没有左右子节点），那么判断剩余的目标和是否为0，如果是，说明找到了一条满足条件的路径，返回True；否则，返回False。
首先，需要更新剩余的目标和，将其减去当前节点的值。然后，如果当前节点有左子节点，那么就递归调用函数，使用左子节点和更新后的目标和作为参数；如果递归调用的结果为True，说明在左子树中找到了满足条件的路径，可以直接返回True。同理，如果当前节点有右子节点，也是同样的逻辑。如果左右子节点都没有找到满足条件的路径，那么就返回False。

代码

递归

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root is None:
            return False
        return self.traversal(root, targetSum - root.val)
    
    def traversal(self, cur, count):
        #递归终止条件
        #遇到叶子节点，并且计数为0
        if not cur.left and not cur.right and count == 0:
            return True
        #遇到叶子节点而没有找到合适的边，直接返回
        if not cur.left and not cur.right:
            return False

        if cur.left:
            count -= cur.left.val
            #如果刚好减完满足target则返回true，如果没有则回溯
            if self.traversal(cur.left, count):
                return True
            count += cur.left.val

        if cur.right:
            count -= cur.right.val
            #已经加满了
            if self.traversal(cur.right, count):
                return True
            count += cur.right.val

        return False


class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        # 此时栈里要放的是pair<节点指针，路径数值>
        st = [(root, root.val)]
        while st:
            node, path_sum = st.pop()
            # 如果该节点是叶子节点了，同时该节点的路径数值等于sum，那么就返回true
            if not node.left and not node.right and path_sum == sum:
                return True
            # 右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
            if node.right:
                st.append((node.right, path_sum + node.right.val))
            # 左节点，压进去一个节点的时候，将该节点的路径数值也记录下来
            if node.left:
                st.append((node.left, path_sum + node.left.val))
        return False

复杂度分析递归

时间复杂度O(N)
空间复杂度O(N)

题目 113. 路径总和ii

问题描述

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。在这里插入图片描述

解题思路

我们从根节点开始，将其加入到当前路径中，并从目标和中减去其值。
对于每个子节点，我们重复上述步骤：将其加入到当前路径中，并从目标和中减去其值。然后，我们检查当前节点是否是叶子节点并且目标和是否为0。如果是，那么我们找到了一条满足条件的路径，将其加入到结果中。
我们回溯到父节点，即将当前节点从路径中移除，并将其值加回到目标和中。然后，我们继续遍历其他的子节点。

代码

递归

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        self.result = []
        self.path = []
        if not root:
            return self.result
        self.path.append(root.val)
        self.traversal(root, targetSum - root.val)
        return self.result

    def traversal(self, cur, count):
        if not cur.left and not cur.right and count == 0:
            self.result.append(self.path[:])
            return

        if not cur.left and not cur.right:
            return

        if cur.left:
            self.path.append(cur.left.val)
            count -= cur.left.val
            self.traversal(cur.left, count)
            count += cur.left.val
            self.path.pop()

        if cur.right:
            self.path.append(cur.right.val)
            count -= cur.right.val
            self.traversal(cur.right, count)
            count += cur.right.val
            self.path.pop()

        return

迭代

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        # 此时栈里要放的是pair<节点指针，路径数值>
        st = [(root, root.val)]
        while st:
            node, path_sum = st.pop()
            # 如果该节点是叶子节点了，同时该节点的路径数值等于sum，那么就返回true
            if not node.left and not node.right and path_sum == sum:
                return True
            # 右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
            if node.right:
                st.append((node.right, path_sum + node.right.val))
            # 左节点，压进去一个节点的时候，将该节点的路径数值也记录下来
            if node.left:
                st.append((node.left, path_sum + node.left.val))
        return False

复杂度分析（递归）

时间复杂度O(N)
空间复杂度O(log(N))
我们需要保存当前路径，最坏情况下，路径长度可能等于二叉树的高度，因此空间复杂度为O(H)，其中H是二叉树的高度。在一般情况下，如果二叉树是平衡的，那么H约等于log(N)，因此空间复杂度约为O(log(N))。

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

问题描述

根据一棵树的中序遍历与后序遍历构造二叉树。在这里插入图片描述请添加图片描述

解题思路

后续数组为0，空节点
后续数组最后一个元素为root元素
寻找中序数组位置作为切割点
切中序数组
切后序数组
递归处理左区间，右区间
无论什么时候前序和后序遍历的长度和所包含元素都相同，知识排列不同而已。

首先，我们观察中序遍历和后序遍历的性质：
中序遍历的顺序是左子树 -> 根节点 -> 右子树。
后序遍历的顺序是左子树 -> 右子树 -> 根节点。

代码


class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        #1st，特殊情况：树为空，或者说是终止递归条件
        if not postorder:
            return None
        #2nd：后序遍历最后一个为当前的中间节点
        root_val=postorder[-1]
        root=TreeNode(root_val)

        #3rd：找切割点
        separator_idx=inorder.index(root_val)
    
        #4th：切割中序，inorder数组，得到左半边和右半边
        inorder_left=inorder[:separator_idx]
        inorder_right=inorder[separator_idx+1:]
        #5th：切割后序，postorder数组，得到左半边，右半边
        postorder_left = postorder[:len(inorder_left)]
        #把已经遍历过的root排除了，所以len(postorder)-1
        postorder_right= postorder[len(inorder_left):len(postorder)-1]
        #！！！重点1:中序数组的大小一定跟后序数组的大小相同
        #6th：递归
        root.left=self.buildTree(inorder_left, postorder_left)
        root.right= self.buildTree(inorder_right, postorder_right)
        #7th：返回答案
        return root

复杂度分析

时间复杂度O(N)
空间复杂度O(N)

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

问题描述

如上一题

解题思路

如上一题

代码


class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        # 第一步: 特殊情况讨论: 树为空. 或者说是递归终止条件
        if not preorder:
            return None

        # 第二步: 前序遍历的第一个就是当前的中间节点.
        root_val = preorder[0]
        root = TreeNode(root_val)

        # 第三步: 找切割点.
        separator_idx = inorder.index(root_val)

        # 第四步: 切割inorder数组. 得到inorder数组的左,右半边.
        inorder_left = inorder[:separator_idx]
        inorder_right = inorder[separator_idx + 1:]

        # 第五步: 切割preorder数组. 得到preorder数组的左,右半边.
        # ⭐️ 重点1: 中序数组大小一定跟前序数组大小是相同的.
        preorder_left = preorder[1:1 + len(inorder_left)]
        preorder_right = preorder[1 + len(inorder_left):]

        # 第六步: 递归
        root.left = self.buildTree(preorder_left, inorder_left)
        root.right = self.buildTree(preorder_right, inorder_right)
        # 第七步: 返回答案
        return root