二叉树相关

LeetCode965. 单值二叉树

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树

# 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 dfs(self,node,val):
#先进行当前节点是否存在的判断
    #     if node.val != val:
    #         self.ans = False
    #         return 
    #     if node.left:左存在
    #         self.dfs(node.left,val)
    #     if node.right:右存在
    #         self.dfs(node.right,val)
    # def isUnivalTree(self, root: Optional[TreeNode]) -> bool:
    #     val = root.val
    #     self.ans = True
    #     self.dfs(root,val)
    #     return self.ans



#递归回传的方式：
#node为当前遍历到的结点
    def dfs(self,node,val):
        if node is None:
            return True
        return node.val ==val and self.dfs(node.left,val) and self.dfs(node.right,val)
    def isUnivalTree(self, root: Optional[TreeNode]) -> bool:
        val =root.val
        return self.dfs(root,val)

LeetCode257. 二叉树的所有路径

给你一个二叉树的根节点 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:
    # 设置的dfs函数用于回溯
    def dfs(self,ans,path,node):
    #path值是当前的路径情况如：1，2，3；  1，2，5
        path.append(str(node.val))#将当前node的值加入到path
    # 到达叶节点时才将答案储存
        if node.left is None and node.right is None:
            ans.append("->".join(path))
        else:
            if node.left:
                self.dfs(ans,path,node.left)
            if node.right:
                self.dfs(ans,path,node.right)
        path.pop()
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        ans =list()
        self.dfs(ans,[],root)
        return ans

LeetCode113. 路经总和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 dfs(self,node,pathSum,targetSum):
        if node is None:
            return
        pathSum += node.val
        #递归终止
        if node.left is None and node.right is None and targetSum == pathSum:
            self.ans = True
            return
        self.dfs(node.left,pathSum,targetSum)
        self.dfs(node.right,pathSum,targetSum)
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root is None:
            return False
        self.ans =False
        self.dfs(root,0,targetSum)
        return self.ans

LeetCode563. 二叉树的坡度

# 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 dfs(self,node):
        if node is None:
            return 0
        left_sum =self.dfs(node.left)
        right_sum =self.dfs(node.right)
        self.ans +=abs(left_sum -right_sum)
        #return的内容应该是当前节点下面（包括自己）的所以节点和
        return left_sum + right_sum + node.val
    def findTilt(self, root: Optional[TreeNode]) -> int:
        self.ans =0
        self.dfs(root)
        return self.ans

LeetCode687. 最长同值路径

# 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 dfs(self, node):
        if node is None:
            return 0
        # 拿到node的左/右子树最大连续同值路径
        left =self.dfs(node.left)
        right =self.dfs(node.right)
        left = left + 1 if node.left and node.left.val == node.val else 0
        right = right + 1 if node.right and node.right.val == node.val else 0
        # 经过node这个点的最长同值路径
        self.ans = max(self.ans, left + right)
        return max(left, right)

    def longestUnivaluePath(self, root: Optional[TreeNode]) -> int:
        self.ans = 0
        self.dfs(root)
        return self.ans

LeetCode124. 二叉树中的最大路径和

# 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
from math import inf
class Solution:
    def dfs(self,node):
        if node is None:
            return 0
        left =self.dfs(node.left)
        right =self.dfs(node.right)
        val =node.val
        max_cur =max(val,val+left,val+right,val+right+left)#max_cur指的是以node为中间结点的最大路径和（而不考虑其上面的节点）
        self.ans =max(self.ans,max_cur)
        return max(val,val+left,val+right)#回传val+left ,val+right才是路径，val+right+left是一个图
    def maxPathSum(self, root: Optional[TreeNode]) -> int:
        self.ans =-inf
        self.dfs(root)
        return self.ans