leetcode-Symmetric Tree 对称树

本文介绍了两种判断二叉树是否轴对称的方法:一种是通过层次遍历并检查每层节点值的对称性;另一种是直接递归或迭代地比较对称位置的节点。提供了详细的代码实现。

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

      判断一个二叉树是否是轴对称的是一个经典的算法问题,下面结合leetcode上的Symmetric Tree给出判断对称树的两种方法。

      先看看问题描述:

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree is symmetric:

    1
   / \
  2   2
 / \ / \
3  4 4  3

But the following is not:

    1
   / \
  2   2
   \   \
   3    3

树的结构:

struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

方法一:

     层次遍历是最直观的方法。对数进行层次遍历,记录每一层的节点,然后对每一层的value组成的字符串判断是不是对称串。算法的时间复杂度为O(nlgn),非最优,侥幸AC。

class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        if(!root)
            return true;
        if(root->left==NULL && root->right!=NULL || root->left!=NULL && root->right==NULL)
            return false;
        if(!root->left && !root->right)
            return true;
        mm.insert(make_pair(root->left,root->right));
        return judge();
    }
private:
    multimap<TreeNode*,TreeNode*> mm;  //存放每层的节点,将对称位置上的一对节点存在一个key-value对里面

    bool judge(){
        if(mm.empty())
            return true;
        multimap<TreeNode*,TreeNode*> tmp(mm);
        mm.clear();
        for(multimap<TreeNode*,TreeNode*>::iterator it=tmp.begin();it!=tmp.end();++it){
            if(it->first->val!=it->second->val)
                return false;
            if(it->first->left && !it->second->right)
                return false;
            if(!it->first->left && it->second->right)
                return false;
            if(it->first->right && !it->second->left)
                return false;
            if(!it->first->right && it->second->left)
                return false;
            if(it->first->right && it->second->left)
                mm.insert(make_pair(it->first->right,it->second->left));
            if(it->first->left && it->second->right)
                mm.insert(make_pair(it->first->left,it->second->right));
        }
        return judge();  //递归到树的下一层
    }
};
方法二:

        不采用层次遍历。直接比较对称位置:left的right和right的left比较,left的left和right的right比较。时间复杂度O(n)下面给出递归和非递归两个版本:

1、递归版本

class Solution {
    public:
    bool isSymmetric(TreeNode *root) {
        return root ? isSymmetric(root->left, root->right) : true;
    }
    bool isSymmetric(TreeNode *left, TreeNode *right) {
        if (!left && !right) return true; 
        if (!left || !right) return false; 
            return left->val == right->val && isSymmetric(left->left, right->right)&& isSymmetric(left->right, right->left);
    }
};
2、非递归版本

class Solution {
public:
    bool isSymmetric (TreeNode* root) {
        if (!root) return true;
        stack<TreeNode*> s;
        s.push(root->left);
        s.push(root->right);
        while (!s.empty ()) {
            auto p = s.top (); s.pop();
            auto q = s.top (); s.pop();
            if (!p && !q) continue;
            if (!p || !q) return false;
            if (p->val != q->val) return false;
            s.push(p->left);
            s.push(q->right);
            s.push(p->right);
            s.push(q->left);
        }
        return true;
    }
};



### LeetCode 101 对称二叉 C语言实现 #### 递归方法 为了判断一棵二叉是否为对称结构,可以采用递归的方法来比较两棵子。具体来说,要验证整棵是否对称,则需确认其左子与右子互为镜像。 对于任意节点而言,只有当该节点的左右孩子均为空或两者皆不为空且值相等时才满足条件;接着再分别对比当前节点左侧孩子的左子同右侧孩子的右子以及左侧孩子的右子同右侧孩子的左子之间的关系即可[^4]。 下面是具体的C语言代码: ```c /** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ bool isMirror(struct TreeNode* t1, struct TreeNode* t2){ if (t1 == NULL && t2 == NULL) return true; // 如果两个都是NULL则返回true if (t1 == NULL || t2 == NULL) return false; // 只有一个是NULL则不对称 // 值相同的情况下继续检查各自的左右分支是否也构成镜子映射的关系 return (t1->val == t2->val) && isMirror(t1->right, t2->left) && isMirror(t1->left, t2->right); } bool isSymmetric(struct TreeNode* root){ return isMirror(root, root); // 调用辅助函数isMirror来进行实际运算 } ``` 此段程序通过定义了一个名为`isMirror()`的帮助函数用于检测给定的一对节点`t1`和`t2`所代表的子之间是否存在镜面对应关系,并最终利用它完成整个过程中的核心逻辑处理工作[^5]。 #### 迭代方法 除了上述提到的基于栈帧调用来解决问题的方式外,还可以借助队列这种数据结构以迭代的形式达成同样的目的——即每次取出一对待考察的对象并将其对应的四个方向上的邻接点依次入队等待后续进一步检验直至遍历完毕为止[^1]。 以下是使用广度优先搜索(BFS)策略下的另一种可能解决方案: ```c #include <stdbool.h> #include <stdlib.h> typedef struct QueueNode{ struct TreeNode *data; struct QueueNode *next; }QueueNode; // 初始化队列操作... void initQueue(QueueNode **front, QueueNode **rear); // 入队操作... void enqueue(QueueNode **front, QueueNode **rear, struct TreeNode *item); // 出队操作... struct TreeNode* dequeue(QueueNode **front, QueueNode **rear); bool check(struct TreeNode *u, struct TreeNode *v){ QueueNode *q_front = NULL,* q_rear = NULL; initQueue(&q_front,&q_rear); enqueue(&q_front,&q_rear,u); enqueue(&q_front,&q_rear,v); while(q_front != NULL){ u = dequeue(&q_front,&q_rear); v = dequeue(&q_front,&q_rear); if(!u && !v) continue; if((!u||!v)||(u->val!=v->val)) return false; enqueue(&q_front,&q_rear,u->left); enqueue(&q_front,&q_rear,v->right); enqueue(&q_front,&q_rear,u->right); enqueue(&q_front,&q_rear,v->left); } return true; } bool isSymmetric(struct TreeNode* root){ return check(root,root); } ``` 这段代码实现了非递归版的算法流程,在这里引入了额外的数据容器(如链表形式表示的队列),以便于按照层次顺序逐层访问各个顶点及其关联边的信息从而达到预期效果。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值