代码随想录算法训练营Day 15|Python|110.平衡二叉树，257. 二叉树的所有路径，404.左叶子之和

110.平衡二叉树

给定一个二叉树，判断它是否是 平衡二叉树

平衡二叉树 是指该树所有节点的左右子树的深度相差不超过 1。

解题思路;

确认输入参数：def get_height(root) 返回所在节点的高度，并左右对比，如果差值大于1返回-1

停止条件：if not root: return 0 （def get_height）

递归逻辑：分别求得左右高度，取最大值，加上当前值return 1+max(left, right)

# 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: Optional[TreeNode]) -> bool:
        if not root:
            return True
        def get_height(root):
            if not root:
                return 0
            left = get_height(root.left)
            right = get_height(root.right)
            if left == -1 or right == -1 or abs(left-right) > 1:
                return -1
            return 1+max(left, right)
        return get_height(root) != -1
            

257. 二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

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

解题思路：

首先检查是否存在根节点，否的话返回None

递归三步骤：

确认递归参数输入：def dfs(root, path, results), path用来存储当前路径，results记录总结果

确认停止条件：if not root.left and not root.right: return results.append(path) 如果是叶子节点，存入results

递归逻辑：else: path += '->' dfs(left, path, results), dfs(right, path, results)

# 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]:
        if not root:
            return
        def dfs(root,path,results):
            if root:
                path += str(root.val)
                if not root.left and not root.right:
                    results.append(path)
                if root.left or root.right:
                    path += '->'
                    dfs(root.left, path, results)
                
                    dfs(root.right, path, results)
            return results
        path = ''
        results = []
        return dfs(root, path, results)

404.左叶子之和

404. 左叶子之和 - 力扣（LeetCode）

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

解题思路：

本体难度在于如何判断该叶子节点为左叶子，因此在进行遍历时对于每个节点，目的是求得该节点children节点的所有左叶子之和，即左边tree的左叶子之和与right tree的左叶子之和。

确定输入参数：def sumoOfLeft(root)

停止条件：没有节点是if not root: return 0; 为叶子节点本身，也返回0：if not root.left and not root.right: return 0

递归逻辑：后序遍历，如何判断一个左叶子节点在于该节点在当前根节点的左边且没有左右叶子，直接将左叶子值进行储存。

访问左子树时，我们希望在到达叶子节点时停止，并累加其值。这就是为什么我们需要在递归调用 self.sumOfLeftLeaves(root.left) 之后立即进行检查。

使用 left_sum 变量的原因是它作为递归函数的返回值，用于存储左子树中所有左叶子节点的值的总和。在每次递归调用时，我们都会计算左子树和右子树的左叶子节点的值的总和，并将它们合并。这样，当我们递归地遍历整个二叉树时，left_sum 将包含所有左叶子节点的值的总和。

# 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:
        # total_left_sum =0
        if not root:
            return 0
        if not root.left and not root.right:
            return 0
    #left tree and its left leaf sum
        left_sum = self.sumOfLeftLeaves(root.left)
        if root.left and not root.left.left and not root.left.right:#the left leaf
            left_sum = root.left.val
        right_sum = self.sumOfLeftLeaves(root.right)
        
        return left_sum+right_sum