1
class TreeNode:
2
    def __init__(self, val=0, left=None, right=None):
3
        self.val = val
4
        self.left = left
5
        self.right = right
6

7
class Solution:
8
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
9
        if not root:
10
            return root
11
        # 交换当前节点的左右子树
12
        root.left, root.right = root.right, root.left
13
        # 递归翻转左子树
14
        self.invertTree(root.left)
15
        # 递归翻转右子树
16
        self.invertTree(root.right)
17
        return root

1
class Solution:
2
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
3
        if not root:
4
            return True
5
        return self.compare(root.left, root.right)
6

7
    def compare(self, left: Optional[TreeNode], right: Optional[TreeNode]) -> bool:
8
        # 检查左右子树是否对称
9
        if left is None and right is not None:
10
            return False
11
        elif left is not None and right is None:
12
            return False
13
        elif left is None and right is None:
14
            return True
15
        elif left.val != right.val:
16
            return False
17
        # 递归比较外侧和内侧的节点是否对称
18
        outside = self.compare(left.left, right.right)
19
        inside = self.compare(left.right, right.left)
20
        return outside and inside

1
class Solution:
2
    def maxDepth(self, root: Optional[TreeNode]) -> int:
3
        res = 0
4
        if not root:
5
            return res
6
        q = deque([root])  # 使用队列进行层序遍历
7
        while q:
8
            size = len(q)
9
            res += 1  # 每遍历一层，深度 +1
10
            for _ in range(size):
11
                cur = q.popleft()
12
                if cur.left:
13
                    q.append(cur.left)
14
                if cur.right:
15
                    q.append(cur.right)
16
        return res

1
class Solution:
2
    # 根节点到最近的叶子节点的最小深度
3
    def minDepth(self, root: Optional[TreeNode]) -> int:
4
        res = 0
5
        if not root:
6
            return res
7
        q = deque([root])
8
        while q:
9
            size = len(q)
10
            res += 1  # 每进入一层，深度加一
11
            for _ in range(size):
12
                cur = q.popleft()
13
                # 如果当前节点是叶子节点，返回当前深度
14
                if not cur.left and not cur.right:
15
                    return res
16
                if cur.left:
17
                    q.append(cur.left)
18
                if cur.right:
19
                    q.append(cur.right)
20
        return res