54.对称的二叉树

最新推荐文章于 2022-05-07 10:51:02 发布
最新推荐文章于 2022-05-07 10:51:02 发布
阅读量421 收藏
点赞数
分类专栏： 在线编程刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengonghao/article/details/51447304
版权
对称的二叉树

题目描述

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
考虑测试用例：

上代码： 
// 53.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <vector>
using namespace::std;

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

class Solution {
public:
	bool isSymmetrical(TreeNode* pRoot) {
		if (pRoot == NULL) return true;

		vector<int> leftVec;
		vector<int> rightVec;

		travLeft(pRoot, leftVec);
		travRight(pRoot, rightVec);

		if (leftVec.size() != rightVec.size()) return false;

		bool retVal = true;
		for (int i = 0; i < leftVec.size(); i++) {
			if (leftVec[i] != rightVec[i]) {
				retVal = false;
				break;
			}
		}
		return retVal;
	}

	void travLeft(TreeNode* pNode, vector<int>& leftVec) {
		//if (pNode == NULL) {
		//	leftVec.push_back(-1);
		//	return;
		//}

		leftVec.push_back(pNode->val);
		if (pNode->left)
			travLeft(pNode->left, leftVec);
		else{
			leftVec.push_back(-1);
			return;
		}
		if (pNode->right)
			travLeft(pNode->right, leftVec);
		else{
			leftVec.push_back(-1);
			return;
		}
	}
	void travRight(TreeNode* pNode, vector<int>& rightVec) {
		//if (pNode == NULL) {
		//	rightVec.push_back(-1);
		//	return;
		//}

		rightVec.push_back(pNode->val);
		if (pNode->right)
			travRight(pNode->right, rightVec);
		else{
			rightVec.push_back(-1);
			return;
		}
		if (pNode->left)
			travRight(pNode->left, rightVec);
		else{
			rightVec.push_back(-1);
			return;
		}
	}
};
int _tmain(int argc, _TCHAR* argv[])
{
	TreeNode p1(5);
	TreeNode p2(5);
	TreeNode p3(5);
	TreeNode p4(5);
	TreeNode p5(5);
	TreeNode p6(5);

	p1.left = &p2;
	p1.right = &p3;
	p2.left = &p4;
	p2.right = &p5;
	p3.left = &p6;

	Solution s;
	bool result = s.isSymmetrical(&p1);
	return 0;
}

思路：
1.对二叉树做前序遍历，把前序遍历的结果装入leftVec中，注意，一般遍历到叶节就返回了，但是这里我们要再进一步，遍历到叶节点的下一位，叶节点的下一位为NULL，如果节点为NULL，就把-1压入leftVec；
2.对二叉树做前序遍历的对称遍历，即先遍历根节点，然后遍历左子节点，再遍历右子节点，把对称遍历的结果装入rightVec ，注意，一般遍历到叶节就返回了，但是这里我们要再进一步，遍历到叶节点的下一位，叶节点的下一位为NULL，如果节点为NULL，就把-1压入rightVec；
3.如果leftVec和rightVec的长度不同，必然退出二叉树不对称，直接返回false；
4.依次对比leftVec和rightVec每个元素值，如果全部相同，说明二叉树对称，否则二叉树不对称；

   travLeft()函数对二叉树做前序遍历，并把前序遍历的结果存入leftVec，先构建二叉树前序遍历的框架：

	void travLeft(TreeNode* pNode, vector<int>& leftVec) {
		leftVec.push_back(pNode->val);
		if (pNode->left).............
		if (pNode->right)............
	}

   再丰富框架： 

	void travLeft(TreeNode* pNode, vector<int>& leftVec) {
		leftVec.push_back(pNode->val);
		if (pNode->left)
			travLeft(pNode->left, leftVec);
		else{
			leftVec.push_back(-1); // 我们要遍历到叶子节点的下一位
			return;
		}
		if (pNode->right)
			travLeft(pNode->right, leftVec);
		else{
			leftVec.push_back(-1); // 我们要遍历到叶子节点的下一位
			return;
		}
	}

   travRight()函数对二叉树做对称前序遍历，并把对称前序遍历的结果存入rightVec，先构建二叉树对称前序遍历的框架： 

	void travRight(TreeNode* pNode, vector<int>& rightVec) {
		rightVec.push_back(pNode->val);
		if (pNode->right)....
		if (pNode->left).......
	}
   再丰富框架： 

	void travRight(TreeNode* pNode, vector<int>& rightVec) {
		rightVec.push_back(pNode->val);
		if (pNode->right)
			travRight(pNode->right, rightVec);
		else{
			rightVec.push_back(-1);// 我们要遍历到叶子节点的下一位
			return;
		}
		if (pNode->left)
			travRight(pNode->left, rightVec);
		else{
			rightVec.push_back(-1); // 我们要遍历到叶子节点的下一位
			return;
		}
	}


第二次做，之前看过一个源码，里面提倡一种理念：函数只有一个出口，第二次做我就采用了这种理念，使用 goto 语句跳转~

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot) {
    	if ( pRoot == NULL ) return true ;
        
        bool rc = false ;
        vector<int> leftVec ;
        vector<int> rightVec ;
        
        startLeft( leftVec, pRoot ) ;
        startRight( rightVec, pRoot ) ;
        
        if ( leftVec.size() != rightVec.size() ) {
            goto done ;
        }
        
        for ( int i = 0; i < leftVec.size(); ++ i ) {
            if ( leftVec[i] != rightVec[i] ) {
                goto done ;
            }
        }
        
        rc = true ;
        
        error :
        	goto done ;
        done :
        	return rc ;
    }
    
    void startLeft( vector<int>& leftVec, TreeNode* pNode ) {
        
        leftVec.push_back( pNode->val ) ;
        
        if ( pNode->left != NULL ) {
            startLeft( leftVec, pNode->left ) ;
        } else {
            leftVec.push_back( -1 ) ;
            return ;
        }
        
        if ( pNode->right != NULL ) {
            startLeft( leftVec, pNode->right ) ;
        } else {
            leftVec.push_back( -1 ) ;
            return ;
        }
    }
    
    void startRight( vector<int>& rightVec, TreeNode* pNode ) {
        
        rightVec.push_back( pNode->val ) ;
        
        if ( pNode->right != NULL ) {
            startRight( rightVec, pNode->right ) ;
        } else {
            rightVec.push_back( -1 ) ;
            return ;
        }
        
        if ( pNode->left != NULL ) {
            startRight( rightVec, pNode->left ) ;
        } else {
            rightVec.push_back( -1 ) ;
            return ;
        }
    }

};


第三次做，一杆过~

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot) {
    	if ( pRoot == NULL ) return true ;
        
        vector<int> vec_left ;
        vector<int> vec_right ;
        
        trav_left( pRoot, vec_left ) ;
        trav_right( pRoot, vec_right ) ;
        
        if ( vec_left.size() != vec_right.size() ) return false ;
        
        for ( int i = 0; i < vec_left.size(); ++ i ) {
            if ( vec_left[i] != vec_right[i] ) return false ;
        }
        return true ;
    }
    
    void trav_left( TreeNode* node, vector<int>& vec_left ) {
        vec_left.push_back( node->val ) ;
        if ( node->left ) trav_left( node->left, vec_left ) ;
        else {
            vec_left.push_back( -1 ) ;
            return ;
        }
        if ( node->right ) trav_left( node->right, vec_left ) ;
        else {
            vec_left.push_back( -1 ) ;
            return ;
        }
    }

    void trav_right( TreeNode* node, vector<int>& vec_right ) {
        vec_right.push_back( node->val ) ;
        if ( node->right ) trav_right( node->right, vec_right ) ;
        else {
            vec_right.push_back( -1 ) ;
            return ;
        }
        if ( node->left ) trav_right( node->left, vec_right ) ;
        else {
            vec_right.push_back( -1 ) ;
            return ;
        }
    }
};


chengonghao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
六.二叉树(easy)
12-18 768
1.二叉树的深度 # 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 class Solution: def maxDepth(self, root: TreeNod.
算法（Java）——二叉树
小朱小朱绝不认输的博客
03-12 1109
二叉树在算法中也是比较常用的数据结构，根据二叉树的遍历算法，在算法题中遇到二叉树经常优先考虑递归算法。同时二叉树中的二叉搜索树也是常用的，主要结合中序遍历有序的特性。 二叉树 ...
P5018 [NOIP2018 普及组] 对称二叉树
weixin_46709784的博客
07-14 262
难度：４ 知识点：二叉树 题意：给你一个二叉树，让你找这个二叉树里面节点数最多的对称子树，这道题我看题解有O(n)的做法，不会，然后我这个是用的最简单的暴力法，递归判断，用的先序，只要当前点为节点的子树是对称的话，那么就没有必要往下判断了，因为就算后面还有对称的子树，它的节点数也不会超过当前点，然后就是怎么判断一个树是不是对称的，我们可以把这个问题转化为判断两个树是不是一样的，第二个树就是第一个树所有左右儿子颠倒之后得到的树， 判断函数的逻辑也比较简单，都空返回是，其中有一个不空返回否，能进行到这里说明都不
Luogu P5018 对称二叉树
YYHS_WSF的博客
11-20 183
看题面戳我 这算是普及组史上最简单的压轴题了吧！ 考场上为啥有人连看起来的暴力都不写呢？蒟蒻发问 最基础的暴力都能过了！ 暴力搜索，暴力判断（如果大小不一样直接返回0，否则继续递归判断），连剪枝都不用 —————————————————————————————————————————————————— 看起来这句话很耐人寻味 Q：这不是? A：错，是 首先暴力判断大小是否一样，最...
P5018 对称二叉树
weixin_30765475的博客
07-29 65
链接：P5018 ---------------------------------- 这道题可以写暴力 ------------------------------ 暴力搜索，首先统计下每一个点的下属节点数，用来统计答案。 然后直接对称搜索就行 ------------------------------- 1 #include<iostream&g...
对称二叉树 二叉树的最大深度（LeetCode第101 104题）
日积月累
11-05 272
# 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(s...
leetcode分类-leetcode-cn-js:前端数据结构和算法系统练习，字节跳动企业题库
06-30
101.对称二叉树 108.将有序数组转换为二叉搜索树 111.二叉树的最小深度 206.反转链表 225.用队列实现栈 232.用栈实现队列 234.回文链表 235.二叉搜索树的最近公共祖先 350.两个数组的交集II 496.下一个最大元素 543....
《剑指Offer》题目及代码.zip
06-28
59. 对称的二叉树 60. 按之字形顺序打印二叉树 61. 把二叉树打印成多行 62. 序列化二叉树 63. 二叉搜索树的第K个节点 64. 数据流中的中位数 65. 滑动窗口的最大值 66. 矩阵中的路径 67. 机器人的运动范围
leetcode之二叉树刷题总结（C++）
L_smartworld的博客
08-04 633
基础知识： 所有的题都是建立在二叉树的前序遍历，中序遍历，后序遍历（它们的递归版与非递归版），及层次遍历。搜索二叉树及平衡二叉树。搜索二叉树是指按照中序遍历，它是从小到大排序的(所以考搜索二叉树基本考中序遍历)。平衡二叉树是指根节点的左右子树总结点相差不能超过1。 参考代码：（上面的遍历方式标准版） #include <iostream> #include <vector> #include <string> #include <stack...
【洛谷luogu】P5018-对称二叉树（递归）
xy160322的博客
04-17 230
原题链接：https://www.luogu.org/problemnew/show/P5018 题目大意 给定二叉树，求其最大的对称子树。 解法 与题解中流传的解法类似，主要是复杂度不好估计。 #include <iostream> #include <ctime> #include <cstdio> #include <cstring> #inc...
[LeetCode 101,104][简单]对称二叉树/二叉树的最大深度
IDrandom的专栏
02-03 123
101.对称二叉树 题目链接 class Solution { public: bool issame(TreeNode* a, TreeNode* b){ if(a == NULL && b == NULL)return true; if(a == NULL || b == NULL)return false; if(a -...
对称的二叉树
桑凯旋的博客
08-05 309
题目： 请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。 方法一： 采用递归，根节点以及其左右子树，左子树的左子树和右子树的右子树相同，左子树的右子树和右子树的左子树相同即可， /* struct TreeNode { int val; struct TreeNode *left; struct Tr...
对称二叉树
China__int128的博客
07-16 361
这是蒟蒻认真写的第一篇题解，如有欠缺，请理解 题目描述 一棵有点权的有根树如果满足以下条件，则被轩轩称为对称二叉树： 1、二叉树； 2、将这棵树所有节点的左右子树交换，新树和原树对应位置的结构相同且点权相等。 下图中节点内的数字为权值，节点外的ididid表示节点编号。 现在给出一棵二叉树，希望你找出它的一棵子树，该子树为对称二叉树，且节点数最多。请输出这棵子树的节点数。 注意：只有树根的树也是对称二叉树。本题中约定，以节点为TTT子树根的一棵“子树”指的是：节点TTT和它的全部后代节点构成的二叉树。 输
LeetCode-最大二叉树
快乐学术猿
11-05 139
1题目要求 原题链接：654. 最大二叉树 分享一个大佬：mata川 给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下： 二叉树的根是数组中的最大元素。 左子树是通过数组中最大值左边部分构造出的最大二叉树。 右子树是通过数组中最大值右边部分构造出的最大二叉树。 通过给定的数组构建最大二叉树，并且输出这个树的根节点。 示例 ： 输入：[3,2,1,6,0,5] 输出：返回下面这棵树的根节点： 6 / \ 3 5 \ / 2
LeetCode刷题：对称二叉树与二叉树的最大深度
qq_51447436的博客
05-07 1万+
LeetCode刷题：对称二叉树与二叉树的最大深度
leetcode_9: 相同的树(100)、对称二叉树（101）、二叉树的最大深度（104）
init_bin的博客
09-05 153
1.相同的树（100） 给定两个二叉树，编写一个函数来检验它们是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 思路：递归 如果当前两个节点都是none, 返回true. 如果当前有一个节点等于none,另一个不是none,返回false 判断两个节点的值，如果不相等，则返回false. 如果相等，则将递归调用。传入的参数分别为当前的节点的左右节点。 #...
【洛谷P5018】对称二叉树
K1385170的博客
11-12 179
题目大意：定义对称二叉树为每个节点的左右子树交换后与原二叉树仍同构的二叉树，求给定的二叉树的最大对称二叉子树的大小。 代码如下 #include <bits/stdc++.h> using namespace std; const int maxn=1e6+10; struct node{ int l,r,size,val; }t[maxn]; int n,ans;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值