leecode第10天

110.平衡二叉树

# 给定一个二叉树，判断它是否是 平衡二叉树 （左右子树高度相差不超过1）
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    
    # 求二叉树的高度
    def maxDepth(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: int
        """
        if not root:
            return 0
        
        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
    


    def isBalanced(self, root):
        """
        判断一棵二叉树是否是平衡的。
        
        平衡的定义是：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1，并且每个子树都是平衡的。
        
        :param root: 二叉树的根节点，类型为TreeNode，表示树的根节点
        :return: 返回一个布尔值，如果这棵树是平衡的，则返回True，否则返回False
        """
        # 如果根节点为空，说明树是平衡的，直接返回True
        if not root: return True
        # 检查左右子树的高度差，并递归地检查左右子树是否平衡
        return abs(self.maxDepth(root.left) - self.maxDepth(root.right)) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)
    
    
    #leecode
        def isBalanced(self, root):
            """
            判断一棵二叉树是否是高度平衡的。
            高度平衡二叉树的定义是：对于任何节点，其两个子树的高度差不超过1。

            参数:
            root: TreeNode类型，二叉树的根节点。

            返回值:
            bool类型，如果二叉树是高度平衡的，则返回True，否则返回False。
            """

            def height(p):
                """
                计算节点p的高度，并检查以p为根的子树是否平衡。
                如果子树不平衡或节点为空，则返回-1。

                参数:
                p: TreeNode类型，当前节点。

                返回值:
                int类型，节点p的高度，如果不平衡则返回-1。
                """
                if p is None:
                    # 如果节点为空，返回高度0
                    return 0
                left_height = height(p.left)
                if left_height == -1:
                    # 如果左子树不平衡，直接返回-1
                    return -1
                right_height = height(p.right)
                if right_height == -1:
                    # 如果右子树不平衡，直接返回-1
                    return -1
                if abs(right_height - left_height) > 1:
                    # 如果左右
                    子树高度差超过1，说明不平衡，返回-1
                    return -1
                return max(left_height, right_height) + 1#返回深度+1
            return height(root) != -1

flowchart TD
    A[开始] --> B{当前节点为空？}
    B -->|是| C[返回高度0]
    B -->|否| D[递归计算左子树高度]
    D --> E{左子树不平衡？}
    E -->|是| F[返回-1]
    E -->|否| G[递归计算右子树高度]
    G --> H{右子树不平衡？}
    H -->|是| I[返回-1]
    H -->|否| J{左右高度差超过1？}
    J -->|是| K[返回-1]
    J -->|否| L[返回最大高度+1]
    M[主函数调用] --> N{高度是否为-1？}
    N -->|是| O[返回False]
    N -->|否| P[返回True]

111.二叉树1最小深度

# 给定一个二叉树，找出其最小深度。

# 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

# 说明：叶子节点是指没有子节点的节点。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
	#自己递归法
    def minDepth(self, root):
        """
        计算二叉树的最小深度。
        
        参数:
        :type root: Optional[TreeNode] - 二叉树的根节点
        
        返回值:
        :rtype: int - 从根节点到最近叶子节点的最短路径上的节点数量

        算法逻辑：
        1. 如果根节点为空，返回0。
        2. 如果根节点没有左右子节点，说明是叶子节点，返回1。
        3. 如果只有右子树，则递归计算右子树的最小深度并加1。
        4. 如果只有左子树，则递归计算左子树的最小深度并加1。
        5. 如果左右子树都存在，则分别递归计算左右子树的最小深度，取较小值并加1。
        """

        # 如果根节点为空，返回0
        if not root:
            return 0
        
        # 如果当前节点是叶子节点（无左右子节点），返回1
        elif not root.left and not root.right:
            return 1
        
        # 如果只有右子树，递归计算右子树的最小深度并加1
        elif not root.left and root.right:
            return self.minDepth(root.right) + 1
        
        # 如果只有左子树，递归计算左子树的最小深度并加1
        elif root.left and not root.right:
            return self.minDepth(root.left) + 1
        
        # 如果左右子树都存在，取左右子树最小深度的较小值并加1
        elif root.left and root.right:
            return min(self.minDepth(root.left), self.minDepth(root.right)) + 1
        
    #leecode迭代法
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        que = deque()
        que.append(root)
        res = 1

        while que:
            for _ in range(len(que)):
                node = que.popleft()
                # 当左右孩子都为空的时候，说明是最低点的一层了，退出
                if not node.left and not node.right:
                    return res
                if node.left is not None:
                    que.append(node.left)
                if node.right is not None:
                    que.append(node.right)
            res += 1
        return res