Leedcode 第九天 二叉树4 python

题目来源力扣
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