代码随想录第13天：（平衡二叉树）

一、平衡二叉树（Leetcode 110）

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        # 判断树是否平衡，调用 get_height 方法
        if self.get_height(root) != -1:
            return True
        else:
            return False

    def get_height(self, root: TreeNode) -> int:
        # 基本情况：如果当前节点为空，返回高度0
        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
        # 如果左右子树高度差超过1，则不平衡，返回-1
        if abs(left_height - right_height) > 1:
            return -1
        # 否则，返回当前树的高度（左右子树的最大高度 + 1）
        else:
            return 1 + max(left_height, right_height)

海象运算符：

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

等价于：

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

二、二叉树的所有路径（Leetcode 257）

class Solution:
    def traversal(self, cur, path, result):
        path.append(cur.val)  # 中
        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  # 返回所有路径

每次进入traversal方法时，将当前节点的值 cur.val 加入 path 列表，表示路径的一部分。cur 是当前的节点，path 是路径列表（存储从根到当前节点的路径），result 是最终结果列表，用于存储所有的路径。

def traversal(self, cur, path, result):
    path.append(cur.val)  # 中

到达叶子节点：如果当前节点没有左子节点和右子节点（即 cur.left 和 cur.right 都为 None），说明到达了一个叶子节点

    if not cur.left and not cur.right:  # 到达叶子节点
        sPath = '->'.join(map(str, path))
        result.append(sPath)
        return

遍历左子树：如果当前节点有左子节点（cur.left 非空），递归调用 traversal 方法来处理左子树。在递归调用后，使用 path.pop() 来回溯，去除路径中当前节点的值，返回到上一层（即回到当前节点的父节点）

    if cur.left:  # 左
        self.traversal(cur.left, path, result)
        path.pop()  # 回溯

遍历右子树：如果当前节点有右子节点（cur.right 非空），递归调用 traversal 方法来处理右子树。同样，递归后使用 path.pop() 回溯，去除路径中的当前节点值。

    if cur.right:  # 右
        self.traversal(cur.right, path, result)
        path.pop()  # 回溯

初始化：result 是一个列表，用于存储所有从根到叶子的路径。path 用于临时存储从根到当前节点的路径。

空树判断：如果 root 为 None，则返回空列表 result，表示没有路径。

调用 traversal 方法：通过调用 self.traversal(root, path, result)，从根节点开始递归遍历整棵树。

返回结果：遍历完成后，result 中存储了所有的路径，最终返回这些路径。

def binaryTreePaths(self, root):
    result = []  # 存储最终的路径结果
    path = []    # 存储从根节点到当前节点的路径
    if not root:
        return result  # 如果树为空，返回空结果
    self.traversal(root, path, result)  # 从根节点开始遍历
    return result  # 返回所有路径

三、左叶子之和（Leetcode 404）

 

class Solution:
    def sumOfLeftLeaves(self, root):
        # 如果根节点为空，返回 0，因为没有节点
        if root is None:
            return 0
        
        # 如果当前节点是叶子节点，且没有子节点，直接返回 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

四、完全二叉树的节点个数（Leetcode 222）

class Solution:
    # 主函数：接收二叉树的根节点，返回二叉树的节点总数
    def countNodes(self, root: TreeNode) -> int:
        # 调用递归函数获取节点数目
        return self.getNodesNum(root)
        
    # 递归函数：用于计算节点数量
    def getNodesNum(self, cur):
        # 基本情况：当前节点为空时，返回 0
        if not cur:
            return 0
        
        # 递归地计算左子树的节点数量
        leftNum = self.getNodesNum(cur.left)  # 左子树的节点数
        # 递归地计算右子树的节点数量
        rightNum = self.getNodesNum(cur.right)  # 右子树的节点数
        
        # 当前树的节点数：左子树的节点数 + 右子树的节点数 + 当前节点本身
        treeNum = leftNum + rightNum + 1  # 中
        return treeNum