Leedcode 第九天二叉树4 python

又南又难

已于 2023-04-02 22:46:55 修改

阅读量190

点赞数

分类专栏： Leetcode 文章标签： python 算法 leetcode

于 2023-04-02 20:16:28 首次发布

本文链接：https://blog.csdn.net/m0_43424109/article/details/129914765

版权

Leetcode 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

文章提供了多个关于二叉树的问题解决方案，包括找到从根节点到叶子节点的所有路径、判断两棵树是否相同、计算左叶子节点的和、查找树的最底层最左边节点的值以及寻找路径总和等于特定值的路径。这些问题主要通过递归和深度优先搜索算法解决。

摘要由CSDN通过智能技术生成

题目来源力扣
257. 二叉树的所有路径
给你一个二叉树的根节点 root ，按任意顺序，返回所有从根节点到叶子节点的路径。叶子节点是指没有子节点的节点。

# 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 binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        path=[]
        def path_(node,res):
            nonlocal path
            if node==None:
                return 
            res.append(node.val)
            if node.left==None and node.right==None:
                path.append(('->').join(str(x) for x in res))
            path_(node.left,res)
            path_(node.right,res)
            res.pop()
        res=[]
        path_(root,res)
        return path

100. 相同的树
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

# 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 isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        def compare(node_p,node_q):
            if node_p==None and node_q==None:
                return True
            elif node_p!=None and node_q==None:
                return False
            elif node_p==None and node_q!=None:
                return False
            elif node_p!=None and node_q!=None:
                if node_p.val!=node_q.val:
                    return False
            a=compare(node_p.left,node_q.left) 
            b=compare(node_p.right,node_q.right) 
            return a and b
        return compare(p,q)

404. 左叶子之和
给定二叉树的根节点 root ，返回所有左叶子之和。

# 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 sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        sum_=0
        def sum_left(node):
            nonlocal sum_
            if node==None:
                return
            if node.left!=None and node.left.left==None and node.left.right==None:
                sum_=sum_+node.left.val

            sum_left(node.left)
            sum_left(node.right)
        sum_left(root)
        return sum_

#############另一种
        if(root==None):
            return 0
        mid=0
        left_=self.sumOfLeftLeaves(root.left)
        right_=self.sumOfLeftLeaves(root.right)
        if root.left!=None and root.left.left==None and root.left.right==None:
                mid=root.left.val
        sum_=0
        sum_=mid+left_+right_
        return sum_

513. 找树左下角的值
给定一个二叉树的根节点 root，请找出该二叉树的最底层最左边节点的值。

假设二叉树中至少有一个节点。

# 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:
        que=[]
        if root.left==None and root.right==None:
            return root.val
        if root.left:
            que.append(root.left)
        if root.right:
            que.append(root.right)
        while(len(que)!=0):
            first_child=que[0]
            size=len(que)
            for i in range (size):
                child=que.pop(0)
                if child.left:
                    que.append(child.left)
                if child.right:
                    que.append(child.right) 
            if len(que)==0:
                return first_child.val

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

叶子节点是指没有子节点的节点。

# 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:
        path_sum=[]
        def dfs(node,sum_):
            if node==None:
                return 
            if node.left==None and node.right==None:
                sum_=sum_+node.val
                path_sum.append(sum_)
                return
            sum_=sum_+node.val
            dfs(node.left,sum_)
            dfs(node.right,sum_)
            sum_=sum_-node.val
        sum_=0
        dfs(root,sum_)
        print(path_sum)
        if targetSum in path_sum:
            return True
        else:
            return False

113. 路径总和 II
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。
叶子节点是指没有子节点的节点。

# 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]]: 
        path_all=[]
        path_=[]
        def dfs(node,target):
            nonlocal path_all
            if node==None:
                return 
            if node.left==None and node.right==None:
                path_.append(node.val)
                if sum(path_)==target:
                    path_all.append(path_[:])
                return
            path_.append(node.val)
            if node.left:
                dfs(node.left,target)
                path_.pop()
            if node.right:
                dfs(node.right,target)
                path_.pop()
            
        dfs(root,targetSum)
        return path_all