给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3]
输出：[2,3,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
from collections import deque
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        # 方法一：这里递归的方法应该是最容易写的
        # if not root: return
        # root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
        # return root

        # 方法二：层序遍历应该也是可以的，常见思路
        if not root:return 
        queue = deque()
        queue.append(root)
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)

        return root

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
        
        def istreessymetric(node1, node2):
            if not node1 and node2:
                return False
            
            if not node2 and node1:
                return False
            
            if not node1 and not node2:
                return True

            return node1.val == node2.val and istreessymetric(node1.left, node2.right) and \
                istreessymetric(node1.right, node2.left)
        
        if not root:
            return True

        return istreessymetric(root.left, root.right)

Better Implementation

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
        
        def is_mirror(n1, n2):
            # 如果两个节点都为空，则对称
            if not n1 and not n2:
                return True
            # 一个为空另一个非空，或值不相等则不对称
            if not n1 or not n2 or n1.val != n2.val:
                return False
            # 递归检查子树：左对右，右对左
            return is_mirror(n1.left, n2.right) and is_mirror(n1.right, n2.left)
        
        # 处理空树情况，并检查左右子树是否互为镜像
        return is_mirror(root.left, root.right) if root else True