LeetCode 101：对称二叉树（多语言解法）

题目LeetCode 101

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

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

Python解法

解法一（递归）

python 复制代码

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        return self.check(root.left, root.right)
    def check(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        #如果都为空
        if p is None and q is None:
            return True
        #如果有一个为空
        if p is None or q is None:
            return False
        #不断递归
        return p.val == q.val and self.check(p.left, q.right) and self.check(p.right, q.left)

解法二（迭代）

python 复制代码

# 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: TreeNode) -> bool:
        # 入口：检查根节点自己和自己是否对称
        return self.check(root, root)

    # 检查 u 和 v 这两棵树是否镜像对称
    def check(self, u: TreeNode, v: TreeNode) -> bool:
        q = deque()
        q.append(u)  # 第一个节点
        q.append(v)  # 镜像节点

        while q:
            # 每次取出一对：左边一个、右边一个
            u = q.popleft()
            v = q.popleft()

            # 都为空 → 对称，继续
            if u is None and v is None:
                continue

            # 一个空一个不空 或 值不相等 → 不对称
            if (u is None or v is None) or (u.val != v.val):
                return False

            # 关键：按镜像顺序入队！
            # u的左 对应 v的右
            q.append(u.left)
            q.append(v.right)

            # u的右 对应 v的左
            q.append(u.right)
            q.append(v.left)

        # 全部比较完都没问题 → 对称
        return True

Java解法

解法一（递归）

java 复制代码

class Solution{
    public boolean isSymmetric(TreeNode root){
        return check(root.left, root.right);
    }
    public boolean check(TreeNode p, TreeNode q){
        if(p == null && q == null){
            return true;
        }
        if(p == null || q == null){
            return false;
        }
        return p.val == q.val && check(p.left, q.right) && check(p.right, q.left);
    }
}

解法二（迭代）

java 复制代码

class Solution {
    public boolean isSymmetric(TreeNode root) {
        // 入口：检查根节点自己和自己是否对称
        return check(root, root);
    }

    // 检查 u 和 v 这两棵树是否镜像对称
    public boolean check(TreeNode u, TreeNode v) {
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(u); // 第一个节点
        q.offer(v); // 镜像节点

        while (!q.isEmpty()) {
            // 每次取出一对：左边一个、右边一个
            u = q.poll();
            v = q.poll();

            // 都为空 → 对称，继续
            if (u == null && v == null) {
                continue;
            }

            // 一个空一个不空 或 值不相等 → 不对称
            if ((u == null || v == null) || (u.val != v.val)) {
                return false;
            }

            // 关键：按镜像顺序入队！
            // u的左 对应 v的右
            q.offer(u.left);
            q.offer(v.right);

            // u的右 对应 v的左
            q.offer(u.right);
            q.offer(v.left);
        }

C++解法

解法一（递归）

cpp 复制代码

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return check(root->left, root->right);
    }

    bool check(TreeNode* p, TreeNode* q) {
        if (p == nullptr && q == nullptr)
            return true;
        if (p == nullptr || q == nullptr)
            return false;
        return p->val == q->val 
            && check(p->left, q->right) 
            && check(p->right, q->left);
    }
};

解法二（迭代）

cpp 复制代码

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }

    bool check(TreeNode* u, TreeNode* v) {
        queue<TreeNode*> q;
        q.push(u);
        q.push(v);

        while (!q.empty()) {
            u = q.front();
            q.pop();
            v = q.front();
            q.pop();

            // 都为空，继续
            if (u == nullptr && v == nullptr)
                continue;

            // 一个空一个不空 或 值不等
            if ((u == nullptr || v == nullptr) || (u->val != v->val))
                return false;

            // 镜像入队
            q.push(u->left);
            q.push(v->right);

            q.push(u->right);
            q.push(v->left);
        }
        return true;
    }
};