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

110. 平衡二叉树：

---

代码思路

判断是否平衡，就是判断左子树和右子树的最深深度之差是否超过1。

# 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 root == None:
            return True
        def max_depth(node, layer):
            if node == None:
                return layer - 1
            elif node != None and node.left == None and node.right == None:
                return layer
            else: # node != None and (node.left != None or node.right != None)
                if node.left == None:
                    return max_depth(node.right, layer + 1)
                elif node.right == None:
                    return max_depth(node.left, layer + 1)
                else:
                    maxdepth = max(max_depth(node.left, layer + 1), max_depth(node.right, layer + 1))
                    return maxdepth

        
        if abs(max_depth(root.left, 1) - max_depth(root.right, 1)) >= 2:
                return False
        else:
            return self.isBalanced(root.left) and self.isBalanced(root.right)
        return True

257. 二叉树的所有路径：

---

代码思路

回溯算法，就是在树的递归函数的形参基础上再传入一个回溯路径。

# 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]:
        res = []
        def dfs(node,path):
            if not root:
                return
            elif node != None and node.left == None and node.right == None:
                temp_path = path + [node]
                str_path = ("->").join([str(i.val) for i in temp_path])
                res.append(str_path)
                return
            else:
                if node.left == None:
                    
                    dfs(node.right, path + [node])
                elif node.right == None:
                    
                    dfs(node.left, path + [node])    
                else:
                    dfs(node.right, path + [node])
                    dfs(node.left, path + [node])   
        dfs(root, []) 
        return res

404. 左叶子之和：

---

代码思路

难点在于判断是左叶子还是右叶子，所以在递归函数里面再传入一个前置节点就可以解决这个问题啦~

# 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:
        if not root or (root.left == None and root.right == None):
            return 0
        def dfs(node, former_node):
            if not node:
                return 0
            else:
                if node.left == None and node.right == None:
                    if node == former_node.left:
                        return node.val
                    else:
                        return 0
                else:
                    return dfs(node.left, node) + dfs(node.right, node)

        return dfs(root, None)