代码随想录算法训练营第十七天 | 110.平衡二叉树、257. 二叉树的所有路径、 404.左叶子之和-CSDN博客

本文链接：https://blog.csdn.net/ordaaaaaa/article/details/130354384

110.平衡二叉树

为什么要用后序遍历：

因为要先判断左右子树，才能进行中间的逻辑判断

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root: TreeNode) -> int:
            if not root:
                return 0
            leftHeight = height(root.left)
            rightHeight = height(root.right)
            if leftHeight == -1 or rightHeight == -1 or abs(leftHeight - rightHeight) > 1:
                return -1
            else:
                return max(leftHeight, rightHeight) + 1

        return height(root) >= 0

# 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 isBalanced(self, root: TreeNode) -> bool:
        if self.get_height(root) != -1:
            return True
        else:
            return False

    def get_height(self, root: TreeNode) -> int:
        if not root:
            return 0

        #左
        if (left_height := self.get_height(root.left)) == -1:
            return -1

        #右
        if (right_height := self.get_height(root.right)) == -1:
            return -1
        #中
        if abs(left_height - right_height) > 1:   #abs绝对值
            return -1
        else:
            return 1 + max(left_height,right_height)

注意这个写法

257. 二叉树的所有路径

是当 cur不为空，其左右孩子都为空的时候，就找到叶子节点

class Solution:
    def binaryTreePaths(self, root: [TreeNode]) -> List[str]:
        path = ''
        result = []
        if not root:
            return result
        self.traversal(root,path,result)
        return result
    
    def traversal(self, cur: TreeNode, path: str, result: List[str]) -> None:
        path += str(cur.val)
        if not cur.left and not cur.right:
            result.append(path)
        if cur.left:
            self.traversal(cur.left,path + '->',result)
        if cur.right:
            self.traversal(cur.right,path + '->',result)

        # def dfs(res,path,root):
        #     if not root:
        #         return []
        #     #设置现场 为什么要放这个位置，如果到5，要判断下面有没有节点，不然会多->
        #     path += str(root.val)
        #     if not root.left and not root.right:
        #         res.append(path[:])
        #         return
        #     #设置现场
        #     path += '->'  
        #     #开始递归
        #     dfs(res,path,root.left)
        #     dfs(res,path,root.right)
        #     #省去回溯
        # res = []
        # path = ''
        # dfs(res,path,root)
        # return res

404.左叶子之和

节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点

思维：先遍历父节点，判断他的左孩子是否为空的同时，判断左孩子的左孩子是否为空，即左孩子就是我们要找的值

# 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:
        self.ans = 0
        def dfs(root):
            if not root:
                return
            if root.left and not root.left.left and not root.left.right:
                self.ans += root.left.val

            dfs(root.left)
            dfs(root.right)
        dfs(root)
        return self.ans

class Solution:
    def sumOfLeftLeaves(self, root: TreeNode) -> int:
        if not root: 
            return 0
        
        left_left_leaves_sum = self.sumOfLeftLeaves(root.left)  # 左
        right_left_leaves_sum = self.sumOfLeftLeaves(root.right) # 右
        
        cur_left_leaf_val = 0
        if root.left and not root.left.left and not root.left.right: 
            cur_left_leaf_val = root.left.val 
            
        return cur_left_leaf_val + left_left_leaves_sum + right_left_leaves_sum # 中