2024/3/21--代码随想录算法训练营day17|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: 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

        left_height = self.get_height(root.left)
        right_height = self.get_height(root.right)
        if left_height == -1:  #如果左子树不平衡，直接返回-1
            return -1
        if right_height == -1: #如果右子树不平衡，直接返回-1
            return -1
        # 中
        if abs(left_height - right_height) > 1:  #如果左右子树高度差大于1，直接返回-1
            return -1
        else:  #当且仅当，左右子树高度差小于等于1，才会返回节点的高度
            return 1 + max(left_height, right_height)

257.二叉树的所有路径

力扣链接

【递归法+回溯】
# Definition for a binary tree node.
class Solution:
    def traversal(self, cur, path, result): #path记录每一条路径 ，result记录结果集， 
        path.append(cur.val)  # 中【如果先判断叶子结点，在执行中，会导致叶子结点，算不入path】
        if not cur.left and not cur.right:  # 到达叶子节点【本题的终止条件，找到叶子结点，就能收获结果】
            sPath = '->'.join(map(str, path))
            result.append(sPath)
            return
        if cur.left:  # 左    【要先判断子树是否为空】
            self.traversal(cur.left, path, result)
            path.pop()  # 回溯
        if cur.right:  # 右
            self.traversal(cur.right, path, result)
            path.pop()  # 回溯

    def binaryTreePaths(self, root):
        result = []
        path = []
        if not root:
            return result
        self.traversal(root, path, result)
        return result

【迭代法】
class Solution:

    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        # 题目中节点数至少为1
        stack, path_st, result = [root], [str(root.val)], []

        while stack:
            cur = stack.pop()
            path = path_st.pop()
            # 如果当前节点为叶子节点，添加路径到结果中
            if not (cur.left or cur.right):
                result.append(path)
            if cur.right:
                stack.append(cur.right)
                path_st.append(path + '->' + str(cur.right.val))
            if cur.left:
                stack.append(cur.left)
                path_st.append(path + '->' + str(cur.left.val))

        return result

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):
        if root is None:
            return 0
        if root.left is None and root.right is None:
            return 0
        
        leftValue = self.sumOfLeftLeaves(root.left)  # 左
        if root.left and not root.left.left and not root.left.right:  # 左子树是左叶子的情况
            leftValue = root.left.val
            
        rightValue = self.sumOfLeftLeaves(root.right)  # 右

        sum_val = leftValue + rightValue  # 中
        return sum_val

【迭代法】
# 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):
        if root is None:
            return 0
        st = [root]
        result = 0
        while st:
            node = st.pop()
            if node.left and node.left.left is None and node.left.right is None:
                result += node.left.val
            if node.right:
                st.append(node.right)
            if node.left:
                st.append(node.left)
        return result