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

513.找树左下角的值

力扣链接
给定一个二叉树的 根节点 root,请找出该二叉树的 最底层 最左边 节点的值。

思路 层序遍历

层序遍历之后,取最后一个数组的第一个元素

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        levels = []
        self.helper(root, 0, levels)
        return levels[-1][0]
    
    def helper(self, node, level, levels):
        if node == None:
            return
        if len(levels)== level:
            levels.append([])
        
        levels[level].append(node.val)
        self.helper(node.left, level+1,levels)
        self.helper(node.right, level+1,levels)

112. 路径总和

力扣链接
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径,这条路径上所有节点值相加等于目标和 targetSum 。如果存在,返回 true ;否则,返回 false 。

思路

二叉树的所有路径一样需要用到回溯,一直遍历到叶子节点,判断这一路上的和是否符合条件,如果不符合则回溯到上一个节点,以此重复。
判断和是否符合要求,可以用target递减的方式,判断最终结果是否为0

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root == None:
            return False
        return self.traversal(root, targetSum-root.val)

    def traversal(self, node, cnt):
        if node.left == None and node.right == None and cnt == 0: # 遇到叶子结点并且计数为0
            return True
        if node.left == None and node.right == None and cnt != 0: # 遇到叶子结点并且计数不为0
            return False

        if node.left:
            cnt -= node.left.val
            if self.traversal(node.left, cnt): 
                return True
            cnt += node.left.val # 回溯

        if node.right:
            cnt -= node.right.val
            if self.traversal(node.right, cnt): 
                return True
            cnt += node.right.val # 回溯
        
        return False

113. 路径总和II

力扣链接
给你二叉树的根节点 root 和一个整数目标和 targetSum ,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

思路

和上一题及二叉树的所有路径很像,为了避免参数混乱可以创建全局变量

class Solution:
    def __init__(self):
        self.result = []
        self.path = []

    def traversal(self, cur, count):
        if not cur.left and not cur.right and count == 0: # 遇到了叶子节点且找到了和为sum的路径
            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

    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        self.result.clear()
        self.path.clear()
        if not root:
            return self.result
        self.path.append(root.val) # 把根节点放进路径
        self.traversal(root, sum - root.val)
        return self.result 

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

力扣链接
给定两个整数数组 inorder 和 postorder ,其中 inorder 是二叉树的中序遍历, postorder 是同一棵树的后序遍历,请你构造并返回这颗 二叉树 。

思路

在这里插入图片描述
第一步:如果数组大小为零的话,说明是空节点了。

第二步:如果不为空,那么取后序数组最后一个元素作为根节点元素。

第三步:找到后序数组最后一个元素在中序数组的位置,作为切割点

第四步:切割中序数组,切成中序左数组和中序右数组 (顺序别搞反了,一定是先切中序数组)

第五步:切割后序数组,切成后序左数组和后序右数组

第六步:递归处理左区间和右区间

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        # 1.判断是否空
        if postorder == []:
            return None
        # 2.后序遍历的最后一个是当前中间节点
        root_val = postorder[-1]
        root = TreeNode(root_val)
        # 3.切割点
        separtor_idx = inorder.index(root_val)
        # 4.切分inorder
        inorder_l = inorder[:separtor_idx]
        inorder_r = inorder[separtor_idx+1:]
        # 5.切分postorder
        postorder_l = postorder[:len(inorder_l)]
        postorder_r = postorder[len(inorder_l):len(postorder)-1]
        # 6.递归
        root.left = self.buildTree(inorder_l, postorder_l)
        root.right = self.buildTree(inorder_r, postorder_r)

        return root

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

力扣链接
给定两个整数数组 preorder 和 inorder ,其中 preorder 是二叉树的先序遍历, inorder 是同一棵树的中序遍历,请构造二叉树并返回其根节点。

思路

与上一题思路类似
第一步:如果数组大小为零的话,说明是空节点了。

第二步:如果不为空,那么取前序数组第一个元素作为根节点元素。

第三步:找到前序数组第一个元素在中序数组中的位置,作为切割点

第四步:切割中序数组,切成中序左数组和中序右数组

第五步:切割前序数组,切成前序左数组和前序右数组

第六步:递归处理左区间和右区间

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        # 1.判断是否为空
        if inorder == []:
            return None
        # 2.前序遍历的第一个是当前中间节点
        root_val = preorder[0]
        root = TreeNode(root_val)
        # 3.切割点
        separtor_idx = inorder.index(root_val)
        # 4.切分inorder
        inorder_l = inorder[:separtor_idx]
        inorder_r = inorder[separtor_idx+1:]
        # 5.切分preorder
        preorder_l = preorder[1:1+len(inorder_l)]
        preorder_r = preorder[1+len(inorder_l):]
        # 6.递归
        root.left = self.buildTree(preorder_l,inorder_l)
        root.right = self.buildTree(preorder_r,inorder_r)

        return root
  • 10
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值