二叉树的构造与一些常见操作(C++描述)

最新推荐文章于 2022-04-19 18:00:44 发布
最新推荐文章于 2022-04-19 18:00:44 发布
阅读量258 收藏 2
点赞数 1
分类专栏： C++ 数据结构与算法 文章标签： 数据结构 队列 二叉树 C++ 代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42430021/article/details/108919303
版权

二叉树的构造与一些常见操作(C++描述)

这是《王道数据结构》中要求读者必须掌握的一些操作，我花了一上午实现了一下，其中大部分操作都是用的递归方法。为了测试，我额外写了诸如构建树和销毁树等函数。

过程中我仅用了几个用例来测试函数，可能有没考虑到的边界情况，如果存在问题，请各位大佬务必在评论区指正。

先直接上代码，等以后有时间再把这些操作整理、完善和扩充。

2020-10-04 二叉树的构建与销毁&遍历&具体操作

#include<iostream>
#include<vector> 
using namespace std;

//此例子中以char为节点类型，作改动时部分函数也需要更改，'#'代表空结点 
typedef char elem; 

//二叉树的二叉链表存储 
typedef struct BNode{
	elem val;
	BNode* left, *right;
	BNode(elem v):left(NULL),right(NULL){
		val = v;
	}
}BTree;

//循环队列---专用于BNode* 
typedef struct Queue{
	static const int MaxSize = 50; //根据输入规模可以调整
	BNode* queue[MaxSize];
	int front, rear;
	Queue():front(0),rear(0){}
	void EnQueue(BNode* node){
		if((rear+1)%MaxSize != front){
			queue[rear] = node;
			rear = (rear+1) % MaxSize;
		}
	}
	void DeQueue(BNode*& e){
		if(front != rear){
			e = queue[front];
			front = (front+1)%MaxSize;
		}
	}
	bool isEmpty(){
		return front == rear;
	}
}Queue;

/********************典型&一般操作的函数原型**********************/
//最基本操作 
void createBTree(BTree*& root, const vector<elem>& v); //创建树 
void destroyBTree(BTree*& root); //销毁树 

//bfs 
void bfs(BTree* root, vector<BNode*>& nodes); //层序遍历
//dfs 
void preorder(BTree* root, vector<BNode*>& nodes); //先序遍历模板 
void inorder(BTree* root, vector<BNode*>& nodes); //中序遍历模板 
void postorder(BTree* root, vector<BNode*>& nodes); //后序遍历模板 
 
void bfsPrint(BTree* root); //按层序遍历顺序打印树的元素(不能体现树形) 
void preOrderPrint(BTree* root, int level=1); //先序打印结点值以及所在层次 

//一些具体的操作 
int calcDegreeNodeCount(BTree* root, int degree); //计算特定度的节点数 
int getBTreeHeight(BTree* root); //获得该树的高度
int getBTreeWidth(BTree* root); //获得树的宽度 
void delBTreeLeaves(BTree*& root); //删除树中所有叶子结点 
int getNodeLayer(BTree* root, BNode* p, int level=1); //获取结点所在层次 
elem getBTreeMaxVal(BTree* root); //获得元素最大值
void swapNodes(BNode* root); //交换结点的子女 
void revertBTree(BTree* root); //翻转整棵二叉树 


/**************************函数定义****************************/ 
//创建BTree
void createBTree(BTree*& root, const vector<elem>& v){
	int n = v.size();
	if(!n || v[0] == '#')
		return;
	
	root = NULL;
	Queue que;
	root = new BNode(v[0]);
	que.EnQueue(root);
	int i=1;
	while (i<n){
		
		BNode* p = NULL;
		if(!que.isEmpty())
			que.DeQueue(p);
		else{
			cout<<"error input"<<endl;
			break;
		}		
		if(v[i] == '#'){
			++i;
			que.EnQueue(NULL); //占位空结点 
		}
		else{
			p->left = new BNode(v[i++]);	
			que.EnQueue(p->left);	
		} 
		
		if(i<n){
			if(v[i] == '#'){
				++i;
				que.EnQueue(NULL); //占位空结点
			}
			else{
				p->right = new BNode(v[i++]);
				que.EnQueue(p->right);	
			}			
		} 
	}
} 

//销毁树 
void destroyBTree(BTree*& root){
	if(!root)
		return;
	destroyBTree(root->left);
	destroyBTree(root->right);
	delete root;
	root = NULL;
}

//按层序遍历序列打印结点值 
void bfsPrint(BTree* root){
	if(!root)
		return;
	Queue que;
	que.EnQueue(root);
	while (!que.isEmpty()){
		BNode* e = NULL;
		que.DeQueue(e);
		cout<<e->val<<" ";

		if(e->left)
			que.EnQueue(e->left);
		if(e->right)
			que.EnQueue(e->right);
	}
	cout<<"\n";
}

//获取BTree中结点度为degree的个数 
int calcDegreeNodeCount(BTree* root, int degree){
	if(!root)
		return 0;
	int left = calcDegreeNodeCount(root->left, degree);
	int right = calcDegreeNodeCount(root->right, degree);
	int deg = 0;
	if(root->left)
		++deg;
	if(root->right)
		++deg;
	if(deg == degree){//度为degree的结点 
		return 1 + left + right;
	}
	return left + right;
}

//获取BTree的高度 
int getBTreeHeight(BTree* root){
	if(!root)
		return 0;
	int left = getBTreeHeight(root->left);
	int right = getBTreeHeight(root->right);
	return 1 + (left > right ? left: right);
}

//获取BTree的宽度
int getBTreeWidth(BTree* root){
	if(!root)
		return 0;
	BNode* lastNode = root;
	BNode* newLastNode = NULL;
	Queue que;
	que.EnQueue(root);
	int curWidth = 0, maxWidth = 0;
	while (!que.isEmpty()){
		BNode* p = NULL;
		que.DeQueue(p);
		curWidth++;
		if(p->left){
			que.EnQueue(p->left);
			newLastNode = p->left;
		}
		if(p->right){
			que.EnQueue(p->right);
			newLastNode = p->right;
		}		
		if(p == lastNode){
			maxWidth = maxWidth>=curWidth?maxWidth:curWidth;
			lastNode = newLastNode;
			curWidth=0;			
		}
	}
	return maxWidth; 
} 

//删除BTree中所有叶子节点 
void delBTreeLeaves(BTree*& root){
	if(!root)
		return;
	if(!root->left && !root->right){
		delete root;
		root = NULL;
		return;
	} 
	delBTreeLeaves(root->left);
	delBTreeLeaves(root->right);
}

//获得指定结点p所在的层级 
int getNodeLayer(BTree* root, BNode* p, int level){
	if(!root){
		return 0; //cannot find
	}
	else if(root == p){
		return level;
	}
	else{
		int left = getNodeLayer(root->left, p, level+1);
		if(!left){
			return getNodeLayer(root->right, p, level+1);
		}
		else
			return left;
	}
	
} 

//层序遍历得到的序列保存在nodes容器中 
void bfs(BTree* root, vector<BNode*>& nodes){
	nodes.clear();
	if(!root)
		return;
	Queue que;
	que.EnQueue(root);
	while (!que.isEmpty()){
		BNode* p = NULL;
		que.DeQueue(p);
		nodes.push_back(p);
		if(p->left){
			que.EnQueue(p->left);
		}
		if(p->right){
			que.EnQueue(p->right);
		}
	}
}

//获得BTree中元素最大值 
elem getBTreeMaxVal(BTree* root){
	if(!root){
		return 0;
	}
	int left=-1, right=-1;
	if(root->left)
		left = getBTreeMaxVal(root->left);
	if(root->right)
		right = getBTreeMaxVal(root->right);
	if(root->val >= left && root->val >= right)
		return root->val;
	else if(left >= root->val && left >= right){
		return left;
	}
	else{
		return right;
	}
}

//先序遍历得到的序列保存在nodes容器中
void preorder(BTree* root, vector<BNode*>& nodes){
	if(!root)
		return;
	nodes.push_back(root);
	preorder(root->left, nodes);
	preorder(root->right, nodes);
}

//中序遍历得到的序列保存在nodes容器中
void inorder(BTree* root, vector<BNode*>& nodes){
	if(!root)
		return;
	inorder(root->left, nodes);
	nodes.push_back(root); 
	inorder(root->right, nodes);
}

//后序遍历得到的序列保存在nodes容器中
void postorder(BTree* root, vector<BNode*>& nodes){
	if(!root)
		return;
	postorder(root->left, nodes);
	postorder(root->right, nodes);
	nodes.push_back(root);	
}

//交换root的子女节点 (翻转) 
void swapNodes(BNode* root){
	if(!root->left && !root->right)
		return; 
	BNode* temp = root->left;
	root->left = root->right;
	root->right = temp;	
}

//翻转整棵树，包括其子树 
void revertBTree(BTree* root){ 
//先后序都行，但中序不可以，因为可能"负负得正 "
	if(!root){
		return;
	}
	swapNodes(root);
	revertBTree(root->left);
	revertBTree(root->right);
}

//先序打印结点元素值以及所在层级 
void preOrderPrint(BTree* root, int level){
	if(!root)
		return;
	cout<<root->val<<" -> "<<level<<endl; 
	preOrderPrint(root->left, level+1);
	preOrderPrint(root->right, level+1);
} 

//操作测试
int main(){
	BTree* root = NULL;
	int N = 15;
	vector<elem> v= vector<elem>(N);
	for (int i=0; i<N; ++i){
		v[i] = 'a' + i;
	}
	v[9] = v[10] = v[11] = v[12] = v[5] = '#';
	
	cout<<"树的形状: ";
	for (int i=0; i<N; ++i)
		cout<<v[i]<<" ";
	cout<<endl;
	cout<<"createTree"<<endl;
	createBTree(root, v);
	cout<<"\nTest bfsPrint(): "<<endl;
	bfsPrint(root);
	
	cout<<"\nTest calcDegreeNodeCount(): "<<endl;
	cout<<"度为1的结点："<<calcDegreeNodeCount(root, 1)<<endl;
	cout<<"度为2的结点："<<calcDegreeNodeCount(root, 2)<<endl;
	cout<<"度为0的结点："<<calcDegreeNodeCount(root, 0)<<endl;
	
	cout<<"\nTest getBTreeHeight(): "<<endl;
	cout<<"树的高度为："<<getBTreeHeight(root)<<endl;
	
	cout<<"\nTest getBTreeWidth(): "<<endl;
	cout<<"树的宽度为："<<getBTreeWidth(root)<<endl;
	/*	
	cout<<"\nTest delBTreeLeaves(): "<<endl;
	cout<<"Before delete: "<<endl;
	bfsPrint(root);
	cout<<"After delete: "<<endl;
	delBTreeLeaves(root);
	bfsPrint(root);
	*/
	cout<<"\nTest getNodeLayer(): "<<endl;
	vector<BNode*> ret;
	bfs(root, ret);
	cout<<"node "<<ret[5]->val<<" is at layer "
	<<getNodeLayer(root, ret[5])<<endl;
	
	cout<<"\nTest getBTreeMaxVal(): "<<endl;
	cout<<"树中最大元素："<<getBTreeMaxVal(root)<<endl;
	
	cout<<"\nTest revertBTree(): "<<endl;
	revertBTree(root); 
	cout<<"树翻转后："<<endl;
	bfsPrint(root);
	
	cout<<"\nTest preOrderPrint(): "<<endl;
	cout<<"格式：结点值 -> 层次"<<endl; 
	preOrderPrint(root); 
	
	destroyBTree(root);
	
	return 0;
}

【运行结果】
在这里插入图片描述

圣☆哥
关注
专栏目录
二叉树的构造（C++）
一只在校程序猿的技术贴
01-25 5411
已知先序序列（preorder）和中序序列（inorder），构造出的二叉树是唯一的。 已知后序序列（postorder）和中序序列（inorder），构造出的二叉树是唯一的。 先序、中序序列构造二叉树，然后先序遍历： #include <cstdio> #include <vector> using namespace std; //声明结点 struct nod...
数据结构C++——二叉树和树
最新发布
qq_60987997的博客
07-23 1184
设完全二叉树中一元素的序号为i, 1≤i≤n。，存在两个不同的二叉树，经过中序遍历都能得到这个结果。但实际上，这两颗二叉树想要实际表达的算式并不相同。与我们希望得到的最为接近。(复制、删除、输出等)。：按照树的层级，从上到下、从左到右依次遍历。：可以看作是缺少了部分元素的完全二叉树。设二叉树中元素数目为n。（前缀和后缀表达式中不会存在歧义）的次序访问树中元素，在同一层中，比如：家庭关系、公司组织……在二叉树的遍历中，每个元素。得到的表达式分别称为其的。树(tree)t是一个。实现，层次遍历通常借助。
二叉树的构造
11-04
树的构造与删除以及各种遍历，求叶子数，以及相互交换
数据结构之二叉树的构建c++版
me_CSDN的博客
11-02 1236
二叉树的构建要注意与链式表的区别，二叉树这里的构建十分低级，每个树只是构建了一个单一的二叉树节点，总体来看是有下向上构建的。用户需要手动去构建自己需要的树，而不是直接去插入数据就到二叉树中了，因为不是链式结构的单一，二叉树十分丰富的。 提一下遍历： 迭代的方式遍历十分简单。先序、中序、后序遍历都只是针对根节点。比如中序，就是先遍历左子树-->根节点-->右子树。（根节点在中间） 下面
【C++】二叉树基本结构+前序构建
Mitchell_Donovan的博客
04-06 468
话不多说，直接上代码???? #include<iostream> using namespace std; template<class T> class BinaryTreeNode { template<class T> friend class BinaryTree;//友元类 private: T data; BinaryTreeNode<T>* leftchild; BinaryTreeNode<T>* rightchi
二叉树的建立
myhome
12-26 572
二叉树的 建立递归算法#include #include #include #include using namespace std; typedef struct BiNode { char data; BiNode *Lchild; BiNode *Rchild; }BiNode; BiNode *Creat(BiNode *bt) { char dt;
C++版数据结构的算术表达式与二叉树
06-08
本项目“C++版数据结构的算术表达式与二叉树”旨在探讨如何将算术表达式转化为二叉树结构，并进行相关操作。以下是关于这个主题的详细知识点： 一、算术表达式与二叉树的关系 算术表达式通常由数字、运算符和括号...
C++数据结构实验指南：线性表、栈队、二叉树与图操作
本次提供的文件标题为"c++数据结构-实验.zip"，该实验包含对数据结构中几个核心概念的实践应用，分别是线性表、栈和队列、二叉树以及图的基本操作。下面将根据标题和描述中的知识点进行详细说明。 1. 线性表的基本...
关于二叉树的一些操作，c++代码描述
07-20
二叉树的几种操作，c++代码描述，包括test case.....
将已知数组元素构造一棵二叉树
06-07
在描述中提到的"将一个数组的各个元素构造为二叉树"，这是一个常见的问题，特别是在构建特定类型的二叉树时，如完全二叉树、满二叉树或平衡二叉树。这个过程通常涉及两个主要步骤：定义树的结构和遍历数组以填充这个...
二叉树的构建
weixin_53316121的博客
04-19 1865
上篇文章中，对二叉树基本操作的前提是我们手动构建了一颗二叉树，那么二叉树正确的构建方式是怎样的呢，这篇文章通过牛客网 练习题：KY11 二叉树遍历 来对正确构建二叉树进行讲解。 目录 做题链接如下： 题目描述 分析 图解如下 代码实现 定义二叉树结点 创建数组，输入相应字符串 前序创建二叉树 中序遍历 中序构建二叉树 后序构建二叉树 做题链接如下： 二叉树遍历_牛客题霸_牛客网 (nowcoder.com) 题目描述 手动输入先序遍历字符串，则是先序构建成二叉...
二叉树的构造以及基本操作
玩转Java
03-06 2789
*二叉树的构造以及基本操作： 二叉树的构造基本思想：循环遍历一段字符串，遇到"(" 就将父结点入指针栈(数组指针),并将变量k置为1，表示接下来构建的是左子树，遇到","，k值置为2,表示接下来要构建的是右子树，遇到")"，表示当前结点左右子树构建完成，将结点出栈。遇到其他的，则创建一个结点指针，并且做相应的赋值操作，每创建的结点要进行定位判断，判断是定位成根结点还是作为左孩子的结点或者作为右孩子的结点。 二叉树的销毁思想： //只要当前结点不为空，则先递归销毁左子树，再销毁右子树，最后销毁当前结点本身，最
数据结构用面向对象方法与c++语言描述
09-04
《数据结构用面向对象方法与C++语言描述》是一本深度探讨如何利用C++编程语言来实现和理解数据结构的著作。这本书的核心在于将面向对象编程的理念与数据结构的理论相结合，为学习者提供了一种现代化的教学方式。通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值