LeetCode算法题101：对称二叉树解析

最新推荐文章于 2024-06-23 21:07:58 发布

哪得小师弟

最新推荐文章于 2024-06-23 21:07:58 发布

阅读量327

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode算法题分析

本文链接：https://blog.youkuaiyun.com/x603560617/article/details/83626993

Leetcode算法题分析专栏收录该内容

156 篇文章

订阅专栏

这篇博客探讨了如何判断一个二叉树是否是对称的，通过递归和迭代两种方法进行解析。递归法从根节点开始，比较左右子节点及其子节点的对称性；迭代法则利用队列存储子节点，逐层比较对应位置的节点值。文中还分析了递归与迭代在该问题中的相似性，并提供了C++和Python3的实现代码。

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

给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

说明:
如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

既然说用两种方法会很加分那就都得会啊，（树结构还是很陌生，代码参考了答案）首先是递归方法，从根节点来开始考虑，首先根节点一定是相同的，然后左子节点要等于右子节点，然后再往下考虑一步，左子节点的左子节点要等于右子节点的右子节点，而且左子节点的右子节点要等于右子节点的左子节点。然后依次往下推，从一开始就比较的是树的左侧和右侧的值。
C++源代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return isMirror(root, root);
    }
    bool isMirror(TreeNode* p, TreeNode* q)
    {
        if(p==NULL&&q==NULL) return true;
        if(p==NULL||q==NULL) return false;
        return (p->val==q->val&&isMirror(p->left,q->right)&&isMirror(p->right, q->left));
    }
};

python3源代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.isMirror(root, root)
    
    def isMirror(self, p, q):
        if p==None and q==None:
            return True
        if p==None or q==None:
            return False
        return p.val==q.val and self.isMirror(p.left, q.right) and self.isMirror(q.left, p.right)

然后说一下迭代，我觉得迭代和递归其实差不多，这里用了队列来存储子节点，每次存一对，左子节点的左子节点和右子节点的右子节点或者左子节点的右子节点和右子节点的左子节点。然后迭代比较这两个点的值。这里产生了一个疑惑，递归用的是栈的原理，而队列其实就是个堆，为什么产生了一样的效果呢？我觉得应该是这样，这里的递归其实并没有用到后面的值，在递归的过程中其实随时可能中断递归，也就是递归的目的是为了遍历整个树，所以和使用队列直接遍历整个树没什么区别。关于迭代方法的思想我觉得其实就是把这个树都按对装到了队列中，然后进行比较，只是代码中在放的过程中进行比较并且将比较过后的删除并给出结果。这个结果是假，那么直接退出，如果是真，继续遍历。
C++源代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        q.push(root);
        while(!q.empty())
        {
            TreeNode* a = q.front();
            q.pop();
            TreeNode* b = q.front();
            q.pop();
            if(a==NULL&&b==NULL) continue;
            if(a==NULL||b==NULL) return false;
            if(a->val!=b->val) return false;
            q.push(a->left);
            q.push(b->right);
            q.push(a->right);
            q.push(b->left);
        }
        return true;
    }
};

python3源代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        q = [root]
        q.append(root)
        while len(q)!=0:
            a = q.pop(0)
            b = q.pop(0)
            if a==None and b==None:
                continue
            if a==None or b==None:
                return False
            if a.val != b.val:
                return False
            q.append(a.left)
            q.append(b.right)
            q.append(b.left)
            q.append(a.right)
        return True