10、二叉树：重载运算符==

最新推荐文章于 2024-05-02 00:37:43 发布
最新推荐文章于 2024-05-02 00:37:43 发布
阅读量403 收藏 1
点赞数
分类专栏： 数据结构提高25题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014377763/article/details/116656281
版权

问题描述 :

内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。）

注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。

 

（2）基本操作15：在二叉树的二叉链表存储形式建立的基础上，使用递归的程序设计方法，设计并完成重载运算符==的算法，用来判断两棵二叉树是否相同。所谓两棵树相同是指树的形状及对应结点的值均相同。完成后将其加入到二叉树的ADT基本操作集中。

初始条件：二叉树T1，T2。

操作结果：若T1和T2相同，返回true。否则，返回false。

 

参考函数原型：

（1）//运算符==重载函数（外壳部分，成员函数形式重载）

//运算符==重载函数  

template<class ElemType>

bool BinaryTree<ElemType>::operator ==(const BinaryTree<ElemType> &T);

 

（2）运算符==重载函数（递归部分，私有成员函数）

//运算符==重载函数

template<class ElemType>

bool BinaryTree<ElemType>::checkEqual(const BinaryTreeNode<ElemType> *root1, const BinaryTreeNode<ElemType> *root2);

 

输入说明 :

第一行：表示无孩子或指针为空的特殊分隔符

第二行：二叉树T1的先序序列（结点元素之间以空格分隔）

第三行：二叉树T2的先序序列（结点元素之间以空格分隔）

 

输出说明 :

第一行：T1与T2相同：true；否则：false

  

输入范例 :

#
A B # C D # # E # # F # G # H # #
A B # C D # # E # # F # G # H # #

输出范例 :

true

思路：

如果A指针的左孩子和右孩子的空、非空状态和元素与B的相同则继续递归

否则修改标记变量。

// tree.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <sstream>
#include <stack>
#include <map>
#include <ctime>
#include <array>
#include <set>
using namespace std;
vector<string> departString_string(string data)
{
	vector<int> back_part;//output type
	int i, j;
	vector<string> part;
	string A_part;
	stringstream room;
	room.str(data);
	while (room >> A_part)
		part.push_back(A_part);
	return part;
}
//————————————————
//版权声明：本文为CSDN博主「systemyff」的原创文章，遵循CC 4.0 BY - SA版权协议，转载请附上原文出处链接及本声明。
//原文链接：https ://blog.csdn.net/u014377763/article/details/113845555
template<class ElemType>
struct tree_point {
	ElemType data;//数据
	struct tree_point* l_child, * r_child;//左、右孩子指针
};
template<class ElemType>
class BinaryTree {
private:
	vector<tree_point<ElemType>*> outlist;
	tree_point<ElemType>* root;   // 头指针
public:
	BinaryTree() :root(NULL)
	{
		//无参数的构造函数
	}
	~BinaryTree()
	{
		//析构函数
	}
	void BinaryTree_fron(vector<ElemType> lis, ElemType nut)
	{
		stack<tree_point<ElemType>*> s;
		tree_point<ElemType>* p_Parent = NULL, * p_Child = NULL;
		int i = 0;
		int flag = 0;//控制左右
		p_Parent = new tree_point<ElemType>;
		p_Parent->data = lis[i];
		p_Parent->l_child = p_Parent->r_child = NULL;
		s.push(p_Parent);
		root = p_Parent;
		i = 1;
		flag = 0;
		while (!s.empty())
		{
			if (lis[i] != nut)
			{
				p_Parent = new tree_point<ElemType>;
				p_Parent->data = lis[i];
				p_Parent->l_child = p_Parent->r_child = NULL;
				if (flag == 0)
				{
					p_Child = s.top();
					p_Child->l_child = p_Parent;
				}
				else if (flag == 1)
				{
					p_Child = s.top();
					s.pop();
					p_Child->r_child = p_Parent;
				}
				s.push(p_Parent);
				flag = 0;
			}
			else
			{
				if (flag == 0)
					flag = 1;
				else if (flag == 1)
					s.pop();
			}
			i++;
		}
	}

	tree_point<ElemType>* get_root()
	{
		return root;
	}
	void qianxu(tree_point<ElemType>* t)
	{
		outlist.push_back(t);
		if (t->l_child != NULL)
			qianxu(t->l_child);
		if (t->r_child != NULL)
			qianxu(t->r_child);
		return;
	}
	void zhongxu(tree_point<ElemType>* t)
	{
		if (t->l_child != NULL)
			zhongxu(t->l_child);
		outlist.push_back(t);
		if (t->r_child != NULL)
			zhongxu(t->r_child);
		return;
	}
	void houxu(tree_point<ElemType>* t)
	{
		if (t->l_child != NULL)
			houxu(t->l_child);
		if (t->r_child != NULL)
			houxu(t->r_child);
		outlist.push_back(t);
		return;
	}
	int c_t = 0;
	void cengxu(tree_point<ElemType>* t)
	{
		vector<tree_point<ElemType>* > q;
		q.push_back(t);
		int last = 1, cur = 0;
		while (cur < q.size())
		{
			last = q.size();
			while (cur < last)
			{
				outlist.push_back(q[cur]);
				if (q[cur]->l_child)
					q.push_back(q[cur]->l_child);
				if (q[cur]->r_child)
					q.push_back(q[cur]->r_child);
				++cur;
			}
			c_t++;
		}
	}
	void out_lis()
	{
		int i;
		for (i = 0; i < outlist.size(); i++)
		{
			cout << outlist[i]->data;
			if (i != outlist.size() - 1)
				cout << ",";
			else
				cout << endl;
		}
		outlist.clear();
	}
	int cnt = 0, p_cnt = 0;
	void t_cnt(tree_point<ElemType>* t)
	{
		p_cnt++;
		if (t->l_child != NULL && t->r_child != NULL)
			cnt++;
		if (t->l_child != NULL)
			t_cnt(t->l_child);
		if (t->r_child != NULL)
			t_cnt(t->r_child);
	}
	int cengshu()
	{
		c_t = 0;
		cengxu(root);
		outlist.clear();
		return c_t;
	}
	int P_cengshu(tree_point<ElemType>* t)
	{
		c_t = 0;
		cengxu(t);
		outlist.clear();
		return c_t;
	}
	int twocnt()
	{
		cnt = 0;
		t_cnt(root);
		return cnt;
	}
	int P_twocnt(tree_point<ElemType>* t)
	{
		cnt = 0;
		t_cnt(t);
		return cnt;
	}
	int pointcnt()
	{
		p_cnt = 0;
		t_cnt(root);
		return p_cnt;
	}
	tree_point<ElemType>* father_p;
	void find_fatherNow(tree_point<ElemType>* t, ElemType ss)
	{
		if (t->l_child != NULL)
			if (t->l_child->data == ss)
			{
				father_p = t;
				return;
			}
		if (t->r_child != NULL)
			if (t->r_child->data == ss)
			{
				father_p = t;
				return;
			}
		if (t->l_child != NULL)
			find_fatherNow(t->l_child, ss);
		if (t->r_child != NULL)
			find_fatherNow(t->r_child, ss);
		return;
	}
	tree_point<ElemType>* find_father(tree_point<ElemType>* t, ElemType ss)
	{
		father_p = NULL;
		find_fatherNow(t, ss);
		return father_p;
	}
	tree_point<ElemType>* nas_p;
	void find_selfNOW(tree_point<ElemType>* t, ElemType ss)
	{
		if (t->data == ss)
			nas_p = t;
		if (t->l_child != NULL)
			find_selfNOW(t->l_child, ss);
		if (t->r_child != NULL)
			find_selfNOW(t->r_child, ss);
		return;
	}
	tree_point<ElemType>* find_self(tree_point<ElemType>* t, ElemType ss)
	{
		nas_p = NULL;
		find_selfNOW(t, ss);
		return nas_p;
	}
	void fast_delChild(tree_point<ElemType>* t, bool flag)
	{
		if (flag == 0)
			t->l_child = NULL;
		else
			t->r_child = NULL;
		return;
	}
	void slow_delChild(tree_point<ElemType>* t, bool flag)
	{
		if (flag == 0)
			t->l_child = NULL;
		else
			t->r_child = NULL;
		return;
	}
	bool is_same = 1;
	bool check_same(tree_point<ElemType>* t1, tree_point<ElemType>* t2)
	{
		if (((t1->l_child != NULL && t2->l_child != NULL) || (t1->l_child == NULL && t2->l_child == NULL))
			&& ((t1->r_child != NULL && t2->r_child != NULL) || (t1->r_child == NULL && t2->r_child == NULL))
			&& t1->data == t2->data)
		{
			if (t1->l_child != NULL)
				check_same(t1->l_child,t2->l_child);
			if (t1->r_child != NULL)
				check_same(t1->r_child, t2->r_child);
		}
		else
		{
			is_same = 0;
			return 0;
		}

	}
	bool operator==(BinaryTree B2)
	{
		is_same = 1;
		check_same(root, B2.get_root());
		return is_same;
	}
};

int main()
{
	string s, ins, ins1, nulls;
	vector<string> part_in, part_in1;
	BinaryTree<string> a;
	BinaryTree<string> b;
	cin >> nulls;
	cin.get();
	getline(cin, ins);
	getline(cin, ins1);
	part_in = departString_string(ins);
	part_in1 = departString_string(ins1);
	a.BinaryTree_fron(part_in, nulls);
	b.BinaryTree_fron(part_in1, nulls);
	if (a == b)
		cout << "true" << endl;
	else
		cout << "false" << endl;
	return 0;
}

 

systemyff
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树根结点到任意结点的路径
nofarewell的专栏
11-29 6159
  准备明年上半年的软件水平考试，学习数据结构中。将课后一些有代表性的习题，添加注解，整理后贴出来，可让自己的思路变得更清晰，更条理，也可与别的学习者们交流问题描述：设二叉树以二叉链结构存储，b为指向根结点指针，x为任一结点类型数据，在树b中寻找x，并打印显示出经过的路径算法思路：1，定义树结点类型，设计创建树函数CreateBTNode()（用一个符号表示法的字符串创建）
二叉树中根结点到某节点的路径（求某结点的所有祖先）
AC_Gibson的专栏
12-15 6211
假设二叉树用二叉链存储结构： 1.对于“找出根结点到叶子节点之间的路径”提供两种不同的算法：用栈辅助的基于后序非递归遍历的算法，和用队列辅助的基于层次遍历的算法。 2.对于某一给定的节点，求出它的所有祖先：递归求解。 具体实现代码如下： #include using namespace std; const int M=1000; typedef struct node { c
二叉树输出从根结点到值为x的结点的路径
凉城浅离的博客
11-06 4115
//假设二叉树采用二叉链存储结构。设计一个递归算法输出从根结点到值为x的结点的路径。假设二叉树中所有结点的值不同 //解法一:采用求x结点的所有祖先的方法，因为x结点加上它的所有祖先恰好构成从根结点到x结点的路径(逆向).用vector向量path存放x结点及其祖先(即从根结点到x结点的逆路径，反向输出构成正向路径)。 //f(b,x,path)(大问题)的求解过程:若b为空时，返回false;若b所指的结点为x结点，将x结点值加入到path，返回true,若b所指结点的孩子为x结点或其祖先，将b所指结点加
算法题:树中根节点到到目标节点的路径java
qq_51050526的博客
11-03 550
【代码】算法题:树中根节点到到目标节点的路径java。
C++:运算符重载（=/==）
最新发布
WolvenSec的博客
05-02 1453
在赋值运算符的重载函数中，首先进行了数值的赋值操作，即将右侧对象的整数成员变量值赋给了左侧对象的相应成员变量。类中包括了两个构造函数：一个是默认构造函数，另一个是带有三个参数的构造函数，用于初始化对象的成员变量。通过重载赋值运算符，可以自定义对象的赋值操作，以便适应特定的需求和语义。注意：使用重载后的赋值运算符时不能将对象的声明与赋值运算符写在一行代码中，即不能在声明对象时初始化对象，如。注意：使用重载后的赋值运算符时不能将对象的声明与赋值运算符写在一行代码中，即不能在声明对象时初始化对象，如。
求根节点到x节点的路径问题
qq_52510579的博客
11-09 3214
题目：求根结点到x结点的路径（假定结点不重复） 输入样例 输入一行字符序列先序递归构建二叉树。每个字符对应一个结点，#表示空结点。第二行输入一个结点值x。 52#3##41##6## 3 输出样例 5 2 3 思路 节点类 class Node{ char val; Node left; Node right; public Node(){ } } 首先先序创建一个二叉树 5 为根节点，2为5的左节点，#为空，即2的左节点为空，2的
二叉树的创建以及遍历
04-22
用递归的方法实现二叉树的创建以及遍历，同时在运用输入运算符重载后，简化了程序的可阅读性。
二叉树（Binary Tree）的C++实现
01-20
二叉树C++头文件，包括构造器、析构器、begin()、end()、output()、destroy()、*、！=运算符重载。
leetcode-solutions:Leetcode问题解决
03-16
5. 构造函数、拷贝构造函数、赋值运算符重载，理解浅拷贝和深拷贝的概念。 6. 动态内存管理：new、delete操作，避免内存泄漏。 7. 面向对象编程：类、继承、多态、封装。 8. 泛型编程和模板：模板类、模板函数，以及...
CodeForces:CodeForces
05-24
1. 基本语法：包括变量声明、数据类型（如int、double、char等）、运算符（如算术、比较、逻辑运算符）、流程控制（if-else、switch-case、for、while循环）。 2. 函数：理解函数的定义、参数传递、返回值以及重载...
algospot:algospot解决方案
05-17
- 函数重载与运算符重载：根据参数类型或数量定义不同功能的同名函数或自定义运算符。 - 内存管理：new和delete操作符进行动态内存分配和释放，避免内存泄漏。 - 命名空间：避免全局命名冲突，提高代码可读性。 ...
二叉树从根结点到指定结点路径的课程设计
07-04
信息。。。。。。。。。。。。。。。。。。。。。。。。。
leetcodetreenode-binary-tree-paths:二叉树路径
07-01
leetcode 树节点二叉树路径 给定一棵二叉树，返回所有从根到叶的路径。 注意：叶子是没有子节点的节点。 Example: Input: 1 / \ 2 3 \ 5 Output: ["1->2->5", "1->3"] Explanation: All root-to-leaf paths are: 1->2->5, 1->3 执行 ： /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { public List< String > binaryTreePaths ( TreeNode root ) { List< String > result = new ArrayList<> (); if (root == null ){ return result; } dfs(root, " " ,resul
求二叉树根节点到指定节点的路径
热门推荐
qq_41512783的博客
11-05 1万+
算法 求二叉树根节点到指定节点的路径 @author:Jingdai @date:2020.11.05 题目描述 给你一个棵二叉树，再给你一个指定的节点，求根节点到指定节点的路径。 如图，比如让你求到 4 节点的路径，则应该返回的路径为 [0, 1, 4] 。 思路 利用二叉树的先序遍历，寻找指定的节点，同时用一个栈 stack 记录遍历到的节点，当找到需要的节点后立即返回结果。但是这样有一个问题，就是在遍历中 stack 记录的路径中包含一些其他的节点，比如要求上图中到 4 节点的路径，则遍历到 4
7-1 求根结点到x结点的路径
rylrmr的博客
11-28 3068
7-1 求根结点到x结点的路径 (10 分)(Python) 求根结点到x结点的路径（假定结点不重复）。 输入样例： 输入一行字符序列先序递归构建二叉树。每个字符对应一个结点，#表示空结点。第二行输入一个结点值x。 52#3##41##6## 3 结尾无空行 输出样例： 输出从根到结点x的路径。 5 2 3 结尾无空行 class BinNode: def __init__(self, data): self.data = data self.left = None
二叉树：重载运算符==
m0_50488710的博客
05-30 279
template<class ElemType> bool BinaryTree<ElemType>::checkEqual(const BinaryTreeNode<ElemType> *root1, const BinaryTreeNode<ElemType> *root2) { if(root1&&root2) { if(root1->Getdata()==root2->Getdata()) { .
重载==运算符
FikaKe的博客
06-10 4633
重载==运算符，用来比较一个复数是否相等，其中Vector2表示的是复数类 bool operator==(const Vector2& other)const { return x==other.x && y == other.y; } 同样，重载！=运算符如下： bool operator!=(const Vector2& other)const { return !(*this == other)； //or return !operator==(othe
c++学习之运算符重载详解
qq_61422622的博客
04-29 6211
重载++和--运算符时，有点让人不知所措，因为我们总希望能根据他们出现在对象的前面还是后面而来调用不同的重载函数，例如当看见++a，会调用前置加加重载函数，看见a++，会调用后置加加的重载函数。++无论前置还是后置，我们发现他的函数重载时设计的参数将会是一样，但这样就无法确定该调用哪一个，考虑到要让参数不一样而来调用对象的前置函数还是后置函数，于是多利用了一个占位参数。这里我们定义了全局函数的+，重载了+运算符，但程序在对运算符调用时，还是会根据参数类型，调用重载后的运算符，还是调用默认的运算符。
C++运算符重载==，＜，＞，＜=，＞=
qq_58665528的博客
01-10 938
运算符重载==，>，<，<=，>=https://blog.csdn.net/qq_58665528/article/details/122414567 以==为例 1. 对于a == b (a.operator==(b))，我们肯定希望b的值不会改，所以要有const修饰，加上希望减少空间开销，提高效率，所以使用引用。所以，参数的类型为const Point& 2. 对于a == b (a.operator==(b))，对于函数的返回值，自然是布尔类型 综上得出.
树与二叉树遍历：中序迭代器实现
`Inorder` 类重载了前置增量运算符 `operator++`，这个操作符在中序遍历中用于移动到下一个节点。如果栈 `s` 为空并且当前节点 `current` 也为 NULL，表示遍历已经结束。如果栈非空，程序会不断地将节点压入栈中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值