leetcode hot100 easy 101. 对称二叉树 递归 层序遍历 bfs

---

判断一棵树是否对称，本质上是看它的左子树和右子树是否互为"镜像"。

递归解法（双指针）

比较左节点和右节点的值是否相等

递归"三部曲"的应用：

1. 出口：

• 两个都为空 → \rightarrow → 对称（True）。
• 一个为空一个不为空 → \rightarrow → 不对称（False）。
• 值不相等 → \rightarrow → 不对称（False）。

2. 操作：

• 比较 left.val 是否等于 right.val。

3. 递归调用：

• 比较"左手的左手"和"右手的右手"（外侧）。比较"左手的右手"和"右手的左手"（内侧）。

时间复杂度 ： O ( N ) O(N) O(N)。每个节点最多被访问一次。
空间复杂度 ：递归： O ( H ) O(H) O(H)，取决于树的高度。

# 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:


        if not root:
            return True

        # 新建一个递归函数，用于比较左右节点（原函数参数只有root, 不方便）
        def check(left, right):

            # 3种出口
            if not left and not right:   #全空
                return True

            if not left or not right:    #单空
                return False

            # 全不空，则比较左右节点的值，和左右节点的外子树， 内子树
            return (left.val == right.val) and check(left.left, right.right) and check(left.right, right.left)

        return check(root.left, root.right)

原函数：任务是"检查这棵树是不是对称的"。

辅助函数：任务是"检查这两个节点是不是镜像的"。

---

层序遍历 bfs （迭代）

层序遍历（BFS）本质上就是迭代

BFS 的标准实现就是利用循环（while）和队列（Queue）进行的迭代

1. 把 root.left 和 root.right 放入队列。
2. 每次弹出两个节点进行比较。
3. 如果比较通过，按照镜像顺序放入它们的后代：
   放入 left.left 和 right.right（外侧一对）。
   放入 left.right 和 right.left（内侧一对）。

时间复杂度 ： O ( N ) O(N) O(N)。每个节点最多被访问一次。
空间复杂度 ： O ( N ) O(N) O(N)，最坏情况下队列会存储大量节点。

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:

        if not root: 
            return True

        # 初始双端队列，放入左右节点
        queue = deque([root.left, root.right])

        while queue:

            # 弹出左右节点
            l = queue.popleft()
            r = queue.popleft()

            # 3种失败
            if not l and not r: 
                continue
            if not l or not r:
                return False
            if l.val != r.val:   # 节点的值不等
                return False

            # 两个节点都存在，且值相等
            # 未来要比较的：成对存入镜像位置的节点
            #外
            queue.append(l.left)
            queue.append(r.right)
            #内
            queue.append(l.right)
            queue.append(r.left)

        return True

            

        

迭代法（BFS）的精髓："队列就是你的待办清单（To-do List）"。