101. Symmetric Tree

最新推荐文章于 2024-01-17 14:31:46 发布

原创最新推荐文章于 2024-01-17 14:31:46 发布 · 177 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

88 篇文章

订阅专栏

本文介绍了两种判断二叉树是否对称的方法：递归法和队列法。递归法通过比较二叉树的左子树和右子树是否为镜像来判断，而队列法则使用队列存储节点，逐层比较左右子树节点的值是否相等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

python:

# 方法一 递归
class Solution1:
    def isSymmetric(self, root):
        if not root:                                 # 先判断根节点是否为空
            return True
        return self.isMirror(root.left, root.right)  # 分成左子树和右子树判断

    def isMirror(self, p, q):                        # 判断两棵树是否是镜像树
        if not p and not q:                          # 根节点都为空，是
            return True
        if not p or not q:                           # 其中有一棵为空，不是
            return False
        l = self.isMirror(p.left, q.right)           # p的左子树和q的右子树是否相同
        r = self.isMirror(p.right, q.left)           # p的右子树和q的左子树是否相同
        return p.val == q.val and l and r            # 值相等，并且p的左=q的右，p的右=q的左

# 方法二 队列实现
class Solution:
    def isSymmetric(self, root):
        """
        队列
        :param root:
        :return:
        """

        if not root:
            return True

        node_queue = [root.left, root.right]  # 在空队列中加入左子树和右子树

        while node_queue:
            left = node_queue.pop(0)          # 依次弹出两个元素
            right = node_queue.pop(0)

            if not right and not left:        # 如果均为空，继续下一个循环
                continue
            if not right or not left:         # 如果只有一个为空，返回False
                return False

            if left.val != right.val:         # 都非空，再判断值是否相等
                return False

            node_queue.append(left.left)      # 将两个左右子树的左右子树逆序加入队列
            node_queue.append(right.right)
            node_queue.append(left.right)
            node_queue.append(right.left)
            #node_queue.extend([left.left, right.right, left.right, right.left])   或者用这一句话写

        return True

C++:

bool isSymmetric(TreeNode* root) {
        TreeNode* l=NULL;
        TreeNode* r=NULL;
        if(!root)
            return true;
        queue<TreeNode*> q;
        q.push(root->left);
        q.push(root->right);
        while(!q.empty())
        {
            l=q.front();
            q.pop();
            r=q.front();
            q.pop();
            if(!l&&!r)
                continue;
            if(!l||!r)
                return false;
            if(l->val!=r->val)
                return false;
            q.push(l->left);
            q.push(r->right);
            q.push(l->right);
            q.push(r->left);
        }
        return true;
        
    }

bool isMirror(TreeNode* p,TreeNode* q){
        bool l=false;
        bool r=false;
        if((!p)&&(!q))
            return true;
        if((!p)||(!q))
            return false;
        l=isMirror(p->left,q->right);
        r=isMirror(p->right,q->left);
        return (p->val==q->val)&&l&&r;
    }
    bool isSymmetric(TreeNode* root) {
        if(!root)
		return true;
	    return isMirror(root->left,root->right);
        
    }