对称序列即中序遍历序列。
分析比较可知，前序序列是EACBDGF，正确答案是B。
只需要注意对称序列其实就是中序序列即可解此题
已知对称序列是ABCDEFG，后序序列是BDCAFGE
后序遍历最后一个结点一定是根结点，这里是E
在中序遍历中进行划分，ABCD-E-FG，分成左子树和右子树
再看后序 BDCA -FG- E，A是左子树的根，根据中序ABCD得出A没有左子树。
以此类推，得到结构
先序遍历则是EACBDGF
对称序列就是中序，先序（根左右），中序（左根右），后序（左右根）
真贱，对称序列？鬼知道什么东西，干嘛不说是中序序列？
这道题你会答吗？花几分钟告诉大家答案吧！
扫描二维码，关注牛客网
下载牛客APP，随时随地刷题
京ICP备号-4
扫一扫，把题目装进口袋/*思路：首先根节点以及其左右&&
boolean isSymmetrical(TreeNode pRoot) {
if (pRoot == null)
return f(pRoot.left,pRoot.right);
boolean f(TreeNode t1, TreeNode t2) {
if (t1 == null && t2 == null)
if (t1 != null && t2 != null)
return t1.val == t2.val && f(t1.left,t2.right) && f(t1.right, t2.left);
代码很简单，关键还是知道怎么样才能判断一个
二叉树是否对称，只要采用前序、中序、后序、层次遍历等任何一种遍历方法，分为先左后右和先
右后左两种方法，只要两次结果相等就说明这棵树是一颗对称二叉树。
class Solution {
bool isSymmetric(TreeNode* root) {
if(root==NULL)
queue&TreeNode*& q1,q2;
TreeNode *left,*
q1.push(root-&left);
q2.push(root-&right);
while(!q1.empty() and !q2.empty())
left = q1.front();
right = q2.front();
//两边都是空
if(NULL==left && NULL==right)
//只有一边是空
if(NULL==left||NULL==right)
if (left-&val != right-&val)
q1.push(left-&left);
q1.push(left-&right);
q2.push(right-&right);
q2.push(right-&left);
struct TreeNode {
struct TreeNode *
struct TreeNode *
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
思路：如果先序遍历的顺序分为两种先左后右和先右后左两种顺序遍历，如果两者相等说明二叉树是对称的二叉树
class Solution {
bool isSymmetrical(TreeNode* pRoot)
return isSymmetrical(pRoot,pRoot);
bool isSymmetrical(TreeNode* pRoot1,TreeNode* pRoot2)
if(pRoot1==NULL&&pRoot2==NULL)
if(pRoot1==NULL || pRoot2==NULL)
if(pRoot1-&val!=pRoot2-&val)
return isSymmetrical(pRoot1-&left,pRoot2-&right) && isSymmetrical(pRoot1-&right,pRoot2-&left);
class Solution {
bool isSame(TreeNode* p1,TreeNode* p2)
if(p1==NULL&&p2!=NULL)
if(p2==NULL&&p1!=NULL)
if(p1==NULL&&p2==NULL)
if(p1-&val==p2-&val)return isSame(p1-&right,p2-&left)
&& isSame(p1-&left,p2-&right);
bool isSymmetrical(TreeNode* pRoot)
if(pRoot==NULL)
return isSame(pRoot-&left,pRoot-&right);
【java代码】满屏递归，无法挖掘这一题的价值。接下来提供递归的一个方法和非递归的2个方法参考。
//===================递归算法=============================//
1.只要pRoot.left和pRoot.right是否对称即可
2.左右节点的值相等且对称子树left.left， right.left.rigth,right.left也对称
boolean isSymmetrical(TreeNode pRoot)
if(pRoot == null)
return isSymmetrical(pRoot.left, pRoot.right);
private boolean isSymmetrical(TreeNode left, TreeNode right) {
if(left == null && right == null)
if(left == null || right == null)
return left.val == right.val //为镜像的条件：左右节点值相等
&& isSymmetrical(left.left, right.right) //2.对称的子树也是镜像
&& isSymmetrical(left.right, right.left);
//===================非递归算法，利用DFS和BFS=============================//
* DFS使用stack来保存成对的节点
* 1.出栈的时候也是成对成对的 ，
1.若都为空，继续；
2.一个为空，返回
3.不为空，比较当前值，值不等，返回false；
* 2.确定入栈顺序，每次入栈都是成对成对的，如left.left， right.left.rigth,right.left
boolean isSymmetricalDFS(TreeNode pRoot)
if(pRoot == null)
Stack&TreeNode& s = new Stack&&();
s.push(pRoot.left);
s.push(pRoot.right);
while(!s.empty()) {
TreeNode right = s.pop();//成对取出
TreeNode left = s.pop();
if(left == null && right == null)
if(left == null || right == null)
if(left.val != right.val)
//成对插入
s.push(left.left);
s.push(right.right);
s.push(left.right);
s.push(right.left);
* BFS使用Queue来保存成对的节点，代码和上面极其相似
* 1.出队的时候也是成对成对的
1.若都为空，继续；
2.一个为空，返回
3.不为空，比较当前值，值不等，返回false；
* 2.确定入队顺序，每次入队都是成对成对的，如left.left， right.left.rigth,right.left
boolean isSymmetricalBFS(TreeNode pRoot)
if(pRoot == null)
Queue&TreeNode& s = new LinkedList&&();
s.offer(pRoot.left);
s.offer(pRoot.right);
while(!s.isEmpty()) {
TreeNode right = s.poll();//成对取出
TreeNode left = s.poll();
if(left == null && right == null)
if(left == null || right == null)
if(left.val != right.val)
//成对插入
s.offer(left.left);
s.offer(right.right);
s.offer(left.right);
s.offer(right.left);
拷贝当前树
对当前树做镜像操作
比较两个树是否相同
public class TreeNode {
int val = 0;
TreeNode left =
TreeNode right =
public TreeNode(int val) {
this.val =
public class Solution {
boolean isSymmetrical(TreeNode pRoot)
TreeNode temp = copyTree(pRoot);
Mirror(pRoot);
return isSameTree(temp, pRoot);
void Mirror(TreeNode root) {
if(root == null)
Mirror(root.left);
Mirror(root.right);
if(root.left!=null || root.right!=null)
TreeNode temp=root.
root.left=root.
root.right=
boolean isSameTree(TreeNode t1,TreeNode t2){
if(t1==null && t2==null)
else if(t1!=null && t2!=null && t1.val==t2.val) {
boolean left = isSameTree(t1.left, t2.left);
boolean right = isSameTree(t1.right, t2.right);
return left &&
TreeNode copyTree (TreeNode root) {
if (root == null)
TreeNode t = new TreeNode(root.val);
t.left = copyTree(root.left);
t.right = copyTree(root.right);
class Solution {
bool isSymmetrical(TreeNode* pRoot)
stack&TreeNode*& s1,s2;
TreeNode *p1,*p2;
while((!s1.empty()&&!s2.empty())||(p1!=NULL&&p2!=NULL)){
while(p1!=NULL&&p2!=NULL){
s1.push(p1);
s2.push(p2);
p1=s1.top();
p2=s2.top();
if(p1-&val!=p2-&val)
if(!s1.empty()||!s2.empty())
if(p1!=NULL||p2!=NULL)
public class Solution {
boolean a=
boolean isSymmetrical(TreeNode pRoot)
if(pRoot==null)
cal(pRoot.left,pRoot.right);
void cal(TreeNode b,TreeNode c){
if(b==null&&c==null){}
if(b!=null&&c==null||b==null&&c!=null){a=}
cal(b.left,c.right);
if(b.val!=c.val){a=}
cal(b.right,c.left);
对称树的话除了跟节点随以外只需将其左右子树镜像对称，进行反方向遍历，如若有不等就返回false即可。
目前好多代码都太复杂了，这里给一个精简的代码
class Solution {
bool isSymmetrical(TreeNode* pRoot)
return aux(pRoot,pRoot);
bool aux(TreeNode* l, TreeNode* r) {
if(l&&r&&l-&val==r-&val)
return aux(l-&left,r-&right)&&aux(l-&right,r-&left);
return !l&&!r;
中序遍历后检查序列是否对称即可
# Python 简单解法，判断左右子节点的值是否相同即可，并通过递归左右节点遍历整个树
# -*- coding:utf-8 -*-
# class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def isSymmetrical(self, pRoot):
# write code here
if not pRoot:
return True
def Traversal(left, right):
if left is None and right is None:
return True
elif left and right and left.val == right.val:
return Traversal(left.left, right.right) and Traversal(left.right, right.left)
return False
return Traversal(pRoot.left, pRoot.right)
class Solution
bool isSymmetrical(TreeNode *p_root1, TreeNode *p_root2)
if (p_root1 == nullptr && p_root2 == nullptr)
// 对称的两个节点为空
else if (p_root1 == nullptr || p_root2 == nullptr)
// 其中一个节点不为空
if (p_root1-&val != p_root2-&val)
// 对称位置的值不相等
// 递归检查对称的位置：p1的左孩子和p2的右孩子，p1的右孩子p2的左孩子
return isSymmetrical(p_root1-&left, p_root2-&right) && isSymmetrical(p_root1-&right, p_root2-&left);
bool isSymmetrical(TreeNode *pRoot)
return isSymmetrical(pRoot, pRoot);
class Solution {
bool isSymmetrical(TreeNode* pRoot)
if(pRoot == NULL)
return helper(pRoot-&left, pRoot-&right);
bool helper(TreeNode* node1, TreeNode* node2){
if(node1==NULL && node2==NULL)
else if(node1!=NULL && node2!=NULL)
return (node1-&val==node2-&val) && helper(node1-&left, node2-&right)
&& helper(node1-&right, node2-&left);
class isSymmetricalTree
bool isSymmetricalCore(TreeNode* pRoot,TreeNode* spRoot) //递归方法判断左右节点是否满足对称性
if(pRoot==nullptr && spRoot==nullptr)
if(pRoot!=nullptr && spRoot!=nullptr && pRoot-&val==spRoot-&val) //树节点值相等
//递归，左右节点全满足对称性
return isSymmetricalCore(pRoot-&left,spRoot-&right) && isSymmetricalCore(pRoot-&right,spRoot-&left);
bool isSymmetrical(TreeNode* pRoot)
if(pRoot==nullptr)
TreeNode* spRoot=pR
return isSymmetricalCore(pRoot,spRoot);
//超简单java递归版本
public class Solution {
boolean isSymmetrical(TreeNode pRoot)
return is(pRoot,pRoot);
boolean is(TreeNode t1,TreeNode t2){
if(t1==null&&t2==null){}
if(t1==null||t2==null){}
if(t1.val==t2.val){return is(t1.left,t2.right)&&is(t1.right,t2.left);}
#Python 版
#思路： 同时进行中左右 和中右左的遍历，并在遍历的时候比较节点
# -*- coding:utf-8 -*-
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def isSymmetrical(self, pRoot):
if pRoot is None:
return True
return self.isSymmetricalCore(pRoot,pRoot)
def isSymmetricalCore(self, pRoot, pRoot1):
if pRoot is None and pRoot1 is None:
return True
if pRoot is None or pRoot1 is None:
return False
if pRoot.val != pRoot1.val :
return False
return self.isSymmetricalCore(pRoot.left,pRoot1.right) and self.isSymmetricalCore(pRoot.right,pRoot1.left)
public class Solution {
boolean isSymmetrical(TreeNode pRoot){
if(pRoot==null)
return isMirror(pRoot.left,pRoot.right);
public boolean isMirror(TreeNode left,TreeNode right){
if(left==null&&right==null)
if((left==null&&right!=null)
||(right==null&&left!=null)
||(left.val!=right.val)
||!(isMirror(left.left,right.right))
||!(isMirror(right.left,left.right))
PYTHON RECURSIVELY # -*- coding:utf-8 -*-
# class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def isSymmetrical(self, pRoot):
# write code here
if pRoot is None:
return True
return self.sub(pRoot.left, pRoot.right)
def sub(self,left,right):
if left is None and right is None:
return True
if left is None or right is None:
return False
if left.val == right.val:
outPair = self.sub(left.left, right.right)
inPair = self.sub(left.right, right.left)
return outPair and inPair
return False
ITERATIVELY # -*- coding:utf-8 -*-
# class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def isSymmetrical(self, pRoot):
# write code here
if pRoot is None:
return True
stack = [[pRoot.left,pRoot.right]]
while stack:
pair = stack.pop()
left = pair[0]
right = pair[1]
if left is None and right is None:
if left is None or right is None:
return False
if left.val == right.val:
stack.append([left.left, right.right])
stack.append([left.right, right.left])
return False
return True
//思路：若一棵树是对称的树，那么它的根节点，左右孩子的值相等，且left.left ==right.right & left,right==right.left
if(pRoot==null){
TreeNode left=pRoot.
TreeNode right=pRoot.
//核心是比较两个值是否相等，left.val==right.val, 同时满足 left.left right.right
left.right right.left 两队值是否相等
return isSymmetricalCore(left,right);
private boolean isSymmetricalCore(TreeNode left,TreeNode right){
// if(left.val!=right.val){
if(left==null && right==null){
if(left==null||right==null){
return left.val==right.val && isSymmetricalCore(left.left,right.right) && isSymmetricalCore(left.right,right.left);
} 二、用栈的思路
//思路：若一棵树是对称的树，那么它的根节点，左右孩子的值相等，且left.left ==right.right & left,right==right.left
if(pRoot==null){
//用非递归算法，用栈stack成对存储
Stack&TreeNode& stack=new Stack();
TreeNode left=pRoot.
TreeNode right=pRoot.
stack.push(left);
stack.push(right);
while(!stack.isEmpty()){
left=stack.pop();
right=stack.pop();
if(left==null &&right==null) // 这地方 可能出现不同的对，其中一个对不满足条件，仍然应该继续往下走，满足为真的一系列条件的一个节点
if(left==null ||right==null)//代码运行到这了，已经过滤了 都为空的情况，剩下的A空B非空 A非空B空
if(left.val!=right.val){
stack.push(left.left);
stack.push(right.right);
stack.push(left.right);
stack.push(right.left);
//此时栈空了，且满足两两成对 值相等所以返回
//递归版本:
public boolean check(TreeNode left,TreeNode right){
if(left==null&&right==null)
if(left==null && right!=null ||left!=null&&right==null)
if(left.val !=right.val)
return check(left.left,right.right)&&check(left.right,right.left);
boolean isSymmetrical(TreeNode pRoot)
if(pRoot==null)
return check(pRoot.left,pRoot.right);
//非递归版本：中序（之前写了一版，然后没考虑完全，竟然也通过了，感觉牛客做的很粗糙）
boolean isSymmetrical(TreeNode pRoot)
if(pRoot==null)
Stack&TreeNode& leftStack = new Stack&TreeNode&();
Stack&TreeNode& rightStack =new Stack&TreeNode&();
TreeNode leftIndex = pR
TreeNode rightIndex = pR
while((leftIndex!=null&&rightIndex!=null) ||(!leftStack.isEmpty()&&!rightStack.isEmpty())){
while(leftIndex!=null&&rightIndex!=null){
if(leftIndex.val !=rightIndex.val)
leftStack.add(leftIndex);
rightStack.add(rightIndex);
leftIndex =leftIndex.
rightIndex =rightIndex.
if(leftIndex==null&&rightIndex==null){
if(!leftStack.isEmpty()&&!rightStack.isEmpty()){
TreeNode tmp1 =leftStack.pop();
TreeNode tmp2 =rightStack.pop();
if(tmp1.left!=null) leftStack.add(tmp1.left);
if(tmp1.right!=null) leftStack.add(tmp1.right);
if(tmp2.left!=null) rightStack.add(tmp2.left);
if(tmp2.right!=null)
rightStack.add(tmp2.right);
if(leftIndex==null&&rightIndex==null)
boolean isSymmetrical(TreeNode pRoot) {
if (pRoot == null) {
return isSymmetricalHelper(pRoot.left, pRoot.right);
boolean isSymmetricalHelper(TreeNode lRoot, TreeNode rRoot) {
if (lRoot == null && rRoot == null) {
if (lRoot == null || rRoot == null) {
if (lRoot.val != rRoot.val) {
return isSymmetricalHelper(lRoot.left, rRoot.right) && isSymmetricalHelper(lRoot.right, rRoot.left);
这道题你会答吗？花几分钟告诉大家答案吧！
扫描二维码，关注牛客网
下载牛客APP，随时随地刷题
京ICP备号-4
扫一扫，把题目装进口袋在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
怎样写一个方法判断两颗二叉树是否互为镜像，也就是说判断第一个树的镜像是否等于第二个树！请指教，先谢谢了
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
java代码如下：
boolean f(TreeNode n1,TreeNode n2){
if(n1==null&&n2==null){
if (n1==null||n2==null) {
if (n1.val!=n2.val) {
return f(n1.left,n2.right)&&f(n1.right,n2.left);
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
镜像树是指左右孩子相反吗？如果是，那么递归判断tree1.left() == tree2.right() && tree1.right() == tree2.left()即可
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。Tree:请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像... - 简书
Tree:请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
boolean isSymmetrical(TreeNode pRoot) {
if (pRoot == null) {
return isMirror(pRoot.left, pRoot.right);
boolean isMirror(TreeNode node1,TreeNode node2) {
if (node1==null&&node2==null) {
if (node1==null||node2==null) {
return node1.val==node2.val?isMirror(node1.left, node2.right)&&isMirror(node1.right, node2.left):
记叙文写作指导 1、记叙文的文体特点及其分类 记叙文是通过记述人物、事件来表明作者思想感情的一种文体。一般说来，记叙文分简单记叙文和复杂记叙文两种。前者只记一人一事，篇幅比较短小; 后者所记的人物或事件不限于一个或一件，写作方法也比较复杂。记叙文是包含面很广的文体，童话、故...
1.容易影响心情。因为西藏行，有点精神恍惚，而且真的有点追求完美，不做完就不想放下，即使明天有很多事要做。
1.室友丢钱，急于摆脱自己的嫌疑，反而显得很有嫌疑。 2.情绪化。精神恍惚，影响打工，影响学习，影响工作。 3.要想成为朋...
X399平台点睛之笔ZENITHEXTREME引爆性能狂潮 近期，X399平台的顶级性能浮出水面，各家媒体的全方位测试犹如一支强心剂，让PC玩家大呼过瘾。我们惊喜地发现，国内外各大科技媒体一致选用了ROGZENITH EXTREME这款主板。它是华硕目前最顶级的X399芯片...
-- 发自我的网易邮箱平板适配版 ----- Original Message ----- From: 163 To: &秦丕兴& Sent: Fri, 15 Sep :27 -0700 Subject: 大营、二营勤俭持家发家、到成为企业家
你是夏天的风， 你是雨后的晴， 你是孩子看到阳光后的笑容。 我是秋天的雨， 我是失眠的梦， 我是森林沼泽地里的幽静。 你那么积极向上，乐观从容。 我那么随遇而安，与世无争。 你有你的追求， 我有我的使命。 你看着我， 我看着你。 我们的眼神里却充满了感动。 你我的世界如此的...
一念生活馆 小苍兰 学名：freesia hybrida klatt 别名：香雪兰、小菖兰、洋晚香玉、麦兰 人贵有德，花贵有香，花姿优雅动人的小苍兰，幽香高雅，其浓郁的香味，非常得人喜爱，可谓醇而不浊，清而不腻，尤其夜间香味更浓。散发着幽香的花朵，沿途被风吹落到雪地，结果连...
001 小时候体弱多病是我的一项特征，从十岁起，便染上了鼻窦炎的疾病。每次鼻窦炎复发，都会引起我全身的连锁反应。说来也怪，虽只是鼻子有问题，可每每都会波及眼睛，肠胃，以致整个人瘫痪，痛苦到极致。 那时的我还小，也从来没有过真正的去想形容那样的疼痛，我只记得它来的时候每次我都...
我想写美人，茶色的美人。古朴素净，像暮暮尘烟，又似月白秋香。只好用素笺描转，相思勾连。
（一） 他定然是爱过她，是海棠香，是白月光，他或许念不出来这些文绉绉的话语，却怎么都明白心里的她是最柔软的停驻。 他和二哥在宋州郊外打猎，第一次遇到了到龙元...请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
就好像一串葡萄有左右两小串葡萄，把两小串葡萄拆下来对比葡萄大小。
Python代码
class Solution:
def isSymmetrical(self, pRoot):
if not pRoot:
return True
return self.recursiveTree(pRoot.left, pRoot.right)
def recursiveTree(self, left, right):
if not left and not right:
return True
if not left or not right:
return False
if left.val == right.val:
return self.recursiveTree(left.left, right.right) and self.recursiveTree(left.right, right.left)
return False
leetcode101 python 对称二叉树
给定一个二叉树，检查它是否是镜像对称的。例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
但是下面这个 [1,2,...
LeetCode--Invert Binary Tree (反转二叉树)Python
给定一个二叉树，将其对称反转。样例如下。
解题思路：
可以发现只要将二叉树从根节点出发，把每一个节点的左子树和右子树对称交换，即可得到整个二叉树的对称交换结果。故使用递归进行反转
java、python语言判断一棵二叉树是否对称
假设一棵二叉树有N层
第二层：左节点=右节点
第三层：左左=右右，左右=右左
第四层：左1左=右1右，左1右=右1左，左2左=右2右，左2右=右2左（1为外，2为内）
剑指offer：对称的二叉树（python）
题目描述请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。# -*- coding:utf-8 -*-
# class TreeNode:
二叉树的镜像[剑指offer]之python实现
题目描述操作给定的二叉树，将其变换为源二叉树的镜像。
二叉树的镜像定义：源二叉树
《剑指offer》对称的二叉树
【 声明：版权所有，转载请标明出处，请勿用于商业用途。
联系信箱：】
题目链接：http://www.nowcoder.com/p...
【leetcode】Python实现-101.对称二叉树
101.对称二叉树
我。。。看了别人的跌跌爬爬写出来的。。。
def isSymmetric(self, root):
对称的二叉树（剑指offer+镜面对称+递归）
对称的二叉树
参与人数：904时间限制：1秒空间限制：32768K通过比例：28.19%最佳记录：0 ms|8552K
请实现一个函数，用来判断一颗二叉树是不是...
【剑指offer】对称二叉树[Python]
题目要求：请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。思路：先写处二叉树的镜像二叉树，然后再判断二者的前序遍历是否一致踩过的坑：1. ...
leet101. 对称二叉树
题目：给定一个二叉树，检查它是否是它自己的镜像（即，围绕它的中心对称）。例如，这个二叉树 [1,2,2,3,4,4,3] 是对称的。
没有更多推荐了，}