二叉树的基本操作(共21个)

这篇具有很好参考价值的文章主要介绍了二叉树的基本操作(共21个)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

先看几条定义:

1、二叉树是一种每个结点最多只能有两个孩子的树。

2、每一个子集本身又是一棵符合定义的树,叫做根节点的子树

3、每一棵子树的根叫做根 r 的孩子,而 r 是每一棵子树的根的双亲。

4、具有相同双亲的结点称为兄弟

5、树中结点所在的最大层次称为树的深度(或高度)。

6、树的访问顺序一般有先序中序后序层次四种。

先序:根结点->左子树->右子树

中序:左子树->根结点->右子树

后序:左子树->右子树->根结点

层次:逐层访问,从左到右

这里我采用的是先序创建。用来测试程序的二叉树为ABD#G###CE##F##,后续插入操作插入的二叉树为HJK####(基于先序顺序)。如图所示:

二叉树的基本操作(共21个)二叉树的基本操作(共21个)

 基本数据结构:

typedef struct BiTNode {
	char data;               //数据
	struct BiTNode* lchild;  //左孩子
	struct BiTNode* rchild;  //右孩子
}BiTNode, * BiTree;

1、初始化

void Init_Tree(BiTree& T)  //1、初始化
{
	T = (BiTNode*)malloc(sizeof(BiTNode));
	T->data = '#';
	T->lchild = NULL;
	T->rchild = NULL;
}

2、销毁(基于后序顺序)

void Destroy_Tree(BiTree& T) //2、销毁(基于后序顺序)
{
	if (T) {
		Destroy_Tree(T->lchild); //销毁左子树
		Destroy_Tree(T->rchild); //销毁右子树
		free(T);                 //释放结点
	}
}

3、创建(基于先序顺序)

void Create_Tree(BiTree& T) //3、创建(基于先序顺序)
{
	char c;
	cin >> c;
	if (c == '#') {  // # 代表空指针
		T = NULL;
	}
	else {           //创建根节点
		T = (BiTNode*)malloc(sizeof(BiTNode));
		T->data = c;
		Create_Tree(T->lchild); //先序创建左分支
		Create_Tree(T->rchild); //先序创建右分支
	}
}

4、清空(释放根之外的空间)

void Clear_Tree(BiTree& T) //4、清空(释放根之外的空间)
{
	Destroy_Tree(T->lchild); //销毁T的左子树
	Destroy_Tree(T->rchild); //销毁T的右子树
	T = NULL;
}

5、判段是否为空

bool Empty_Tree(BiTree T) //5、判空
{
	if (T == NULL || T->data == '#') {  
		return true;
	}
	else {
		return false;
	}
}

6、求深度

int Depth_Tree(BiTree T)  //6、返回深度
{
	int leftdepth, rightdepth;
	if (T == NULL) {
		return 0;     //到空时,返回0
	}
	else {
		leftdepth = Depth_Tree(T->lchild);   //求左子树深度
		rightdepth = Depth_Tree(T->rchild);  //求右子树深度
		return max(leftdepth + 1, rightdepth + 1);   //最终取较大深度
	}
}

7、返回根的元素值

8、返回p指针指向的结点值

char Root_Tree(BiTree T) //7、返回根的元素值
{
	if (T != NULL) {     //树不为空
		return T->data;
	}
	else {
		return '#';
	}
}

char Value_Tree(BiTree T, BiTree p) //8、返回p指针指向的结点值
{
	if (T == NULL || p == NULL) {
		return '#';
	}
	else {
		return p->data;
	}
}

9、若p非T的根节点,则返回其双亲指针,否则返回NULL

10、返回p的左孩子指针,若没有返回NULL

11、返回p的右孩子指针,若没有返回NULL

12、返回p的左兄弟指针,若没有返回NULL

13、返回p的右兄弟指针,若没有返回NULL

BiTree Parent_Tree(BiTree T, BiTree p) //9、若p非T的根节点,则返回其双亲指针,否则返回NULL
{
	BiTree q = NULL;
	if (T == NULL || p == T) {  //如果p等于根节点,返回NULL
		return NULL;
	}
	else {
		if (T->lchild == p || T->rchild == p) { //T是p的双亲,返回T
			return T;
		}
		q = Parent_Tree(T->lchild, p);  //在左分支中查找
		if (q == NULL) {                //左分支中没有找到,查找右分支
			q = Parent_Tree(T->rchild, p);
			return q;
		}
		return q;
	}
}

BiTree LeftChild_Tree(BiTree T, BiTree p) //10、返回p的左孩子指针,若没有返回NULL
{
	if (T != NULL && p != NULL) {
		return p->lchild;
	}
	else {
		return NULL;
	}
}

BiTree RightChild_Tree(BiTree T, BiTree p) //11、返回p的右孩子指针,若没有返回NULL
{
	if (T != NULL && p != NULL) {
		return p->rchild;
	}
	else {
		return NULL;
	}
}

BiTree LeftBrother_Tree(BiTree T, BiTree p) //12、返回p的左兄弟指针,若没有返回NULL
{
	if (T == NULL) {
		return NULL;
	}
	else {
		BiTree q = Parent_Tree(T, p);   //先找到双亲结点
		if (q != NULL && q->lchild != p) {
			return q->lchild;
		}
		else {
			return NULL;
		}
	}
}

BiTree RightBrother_Tree(BiTree T, BiTree p) //13、返回p的右兄弟指针,若没有返回NULL
{
	if (T == NULL) {
		return NULL;
	}
	else {
		BiTree q = Parent_Tree(T, p);
		if (q != NULL && q->rchild != p) {
			return q->rchild;
		}
		else {
			return NULL;
		}
	}
}

14、先序遍历并打印

15、中序遍历并打印

16、后序遍历并打印

void PrePrint_Tree(BiTree T)  //14、先序遍历并打印
{
	if (T != NULL) {
		cout << T->data;     //访问根节点
		PrePrint_Tree(T->lchild); //先序遍历左子树
		PrePrint_Tree(T->rchild); //先序遍历右子树
	}
}

void InPrint_Tree(BiTree T)  //15、中序遍历并打印
{
	if (T != NULL) {
		InPrint_Tree(T->lchild);  //中序遍历左子树
		cout << T->data;          //访问根节点
		InPrint_Tree(T->rchild);  //中序遍历右子树
	}
}

void PostPrint_Tree(BiTree T)  //16、后序遍历并打印
{
	if (T != NULL) {
		PostPrint_Tree(T->lchild); //后序遍历左子树
		PostPrint_Tree(T->rchild); //后序遍历右子树
		cout << T->data;          //访问根节点
	}
}

17、层次遍历并打印

void LevelPrint_Tree(BiTree T)  //17、层次遍历并打印
{
	BiTree p;
	queue<BiTree>qu;  //定义队列,存放二叉树结点指针(这里使用了STL的queue类型)
	qu.push(T);       //根节点入队
	while (!qu.empty()) {
		p = qu.front();
		cout << p->data;  //访问队首结点
		qu.pop();         //队首结点出队
		if (p->lchild != NULL) {
			qu.push(p->lchild);  //若结点有左孩子,则左孩子入队
		}
		if (p->rchild != NULL) {
			qu.push(p->rchild);  //若结点有右孩子,则左孩子入队
		}
	}
}

18、将p结点元素赋值为c

19、插入(插入的为非空二叉树,且右子树为空)

void Assign_Tree(BiTree& T, BiTree p, char c) //18、将p结点元素赋值为c
{
	if (T == NULL || p == NULL) {
		return;
	}
	else {
		p->data = c;
	}
}

void Insert_Tree(BiTree& T, BiTree p, int LR, BiTree c) //19、插入(c为非空二叉树,且右子树为空)
{
	if (T == NULL || p == NULL || c == NULL) {
		return;
	}
	else {
		if (LR == 0) { //LR为0,则c作为p的左子树;为1,则c作为p的右子树
			c->rchild = p->lchild; //把原来的左子树连接在c的右子树上
			p->lchild = c;
		}
		else {
			c->rchild = p->rchild; //把原来的右子树连接在c的右子树上
			p->rchild = c;
		}
	}
}

20、删除子树

void Delete_Tree(BiTree& T, BiTree p, int LR)  //20、删除子树
{
	if (T == NULL || p == NULL) {
		return;
	}
	if (LR == 0) { //删除p的左子树
		Destroy_Tree(p->lchild);
		p->lchild = NULL;
	}
	else {  //删除p的右子树
		Destroy_Tree(p->rchild);
		p->rchild = NULL;
	}
}

21、先序查找指定元素值的结点

BiTree Find_Tree(BiTree T, char c)  //21、先序查找指定元素值的二叉树结点
{
	BiTree p = NULL;
	if (T == NULL) {
		return NULL;
	}
	else if (T->data == c) {  //访问的当前结点值等于c,返回当前指针,查找结束
		return T;
	}
	else {
		p = Find_Tree(T->lchild, c);  //在左分支中先序查找
		if (p == NULL) {
			p = Find_Tree(T->rchild, c); //左分支中未找到,继续先序查找右分支
			return p; //返回右分支查找结果
		}
		return p; //左分支中找到,返回当前指针,查找结束
	}
}

主函数(用于测试):

int main()
{
	BiTree T;
	Init_Tree(T);                //1、初始化
	bool t = Empty_Tree(T);      //5、判空
	if (t) {
		cout << "二叉树为空" << endl;
	}
	else {
		cout << "二叉树非空" << endl;
	}
	cout << "按先序顺序输入元素:";
	Create_Tree(T);              //3、创建
	int d = Depth_Tree(T);       //6、返回深度
	cout << "二叉树的深度:" << d << endl;
	char c = Root_Tree(T);       //7、返回根的元素值
	cout << "根的元素值为:" << c << endl;
	BiTree p, q;  //p为检验程序时使用,可随意更改p的指向
	cout << "请设置p指针指向的元素:";
	cin >> c;
	p = Find_Tree(T, c);         //21、先序查找指定元素值的二叉树结点
	c = Value_Tree(T, p);        //8、返回p指针指向的结点值
	cout << "p指向的结点值:" << c << endl;
	q = Parent_Tree(T, p);       //9、若p非T的根节点,则返回其双亲指针,否则返回NULL
	cout << "p的双亲指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = LeftChild_Tree(T, p);    //10、返回p的左孩子指针,若没有返回NULL
	cout << "p的左孩子指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = RightChild_Tree(T, p);   //11、返回p的右孩子指针,若没有返回NULL
	cout << "p的右孩子指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = LeftBrother_Tree(T, p);  //12、返回p的左兄弟指针,若没有返回NULL
	cout << "p的左兄弟指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = RightBrother_Tree(T, p); //13、返回p的右兄弟指针,若没有返回NULL
	cout << "p的右兄弟指针q指向的元素:" << Value_Tree(T, q) << endl;
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	cout << "中序遍历二叉树:";
	InPrint_Tree(T);             //15、中序遍历并打印
	cout << endl;
	cout << "后序遍历二叉树:";
	PostPrint_Tree(T);           //16、后序遍历并打印
	cout << endl;
	cout << "层次遍历二叉树:";
	LevelPrint_Tree(T);          //17、层次遍历并打印
	cout << endl;
	cout << "想要更改的元素值:";
	cin >> c;
	q = Find_Tree(T, c);         //21、先序查找指定元素值的二叉树结点
	cout << "更改后的元素值:";
	cin >> c;
	Assign_Tree(T, q, c);        //18、将p结点元素赋值为c
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	BiTree S;  //另创建一个根节点右子树为空的二叉树,作为插入的样本
	Init_Tree(S);                //1、初始化
	cout << "按先序顺序输入要插入的二叉树(根节点右子树为空)的元素:";
	Create_Tree(S);              //3、创建
	int LR;
	cout << "请选择要插入的部位(0.p的左子树 1.p的右子树):";
	cin >> LR;
	Insert_Tree(T, p, LR, S);    //19、插入(S为非空二叉树,且右子树为空)
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	cout << "请选择要删除的部位(0.p的左子树 1.p的右子树):";
	cin >> LR;
	Delete_Tree(T, p, LR);       //20、删除子树
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	cout << "二叉树已清空" << endl;
	Clear_Tree(T);               //4、清空(释放根之外的空间)
	t = Empty_Tree(T);           //5、判空
	if (t) {
		cout << "二叉树为空" << endl;
	}
	else {
		cout << "二叉树非空" << endl;
	}
	Destroy_Tree(T);             //2、销毁(基于后序顺序)
	cout << "二叉树已销毁" << endl;
	return 0;
}

下面是全部代码:

# include <iostream>
# include <stdlib.h>
# include <queue>
# define SIZE 256
using namespace std;

typedef struct BiTNode {
	char data;
	struct BiTNode* lchild;  //左孩子
	struct BiTNode* rchild;  //右孩子
}BiTNode, * BiTree;

void Init_Tree(BiTree& T)  //1、初始化
{
	T = (BiTNode*)malloc(sizeof(BiTNode));
	T->data = '#';
	T->lchild = NULL;
	T->rchild = NULL;
}

void Destroy_Tree(BiTree& T) //2、销毁(基于后序顺序)
{
	if (T) {
		Destroy_Tree(T->lchild); //销毁左子树
		Destroy_Tree(T->rchild); //销毁右子树
		free(T);
	}
}

void Create_Tree(BiTree& T) //3、创建(基于先序顺序)
{
	char c;
	cin >> c;
	if (c == '#') {  // # 代表空指针
		T = NULL;
	}
	else {           //创建根节点
		T = (BiTNode*)malloc(sizeof(BiTNode));
		T->data = c;
		Create_Tree(T->lchild); //先序创建左分支
		Create_Tree(T->rchild); //先序创建右分支
	}
}

void Clear_Tree(BiTree& T) //4、清空(释放根之外的空间)
{
	Destroy_Tree(T->lchild); //销毁T的左子树
	Destroy_Tree(T->rchild); //销毁T的右子树
	T = NULL;
}

bool Empty_Tree(BiTree T) //5、判空
{
	if (T == NULL || T->data == '#') {  
		return true;
	}
	else {
		return false;
	}
}

int Depth_Tree(BiTree T)  //6、返回深度
{
	int leftdepth, rightdepth;
	if (T == NULL) {
		return 0;     //到空时,返回0
	}
	else {
		leftdepth = Depth_Tree(T->lchild);   //求左子树深度
		rightdepth = Depth_Tree(T->rchild);  //求右子树深度
		return max(leftdepth + 1, rightdepth + 1);   //最终取较大深度
	}
}

char Root_Tree(BiTree T) //7、返回根的元素值
{
	if (T != NULL) {     //树不为空
		return T->data;
	}
	else {
		return '#';
	}
}

char Value_Tree(BiTree T, BiTree p) //8、返回p指针指向的结点值
{
	if (T == NULL || p == NULL) {
		return '#';
	}
	else {
		return p->data;
	}
}

BiTree Parent_Tree(BiTree T, BiTree p) //9、若p非T的根节点,则返回其双亲指针,否则返回NULL
{
	BiTree q = NULL;
	if (T == NULL || p == T) {  //如果p等于根节点,返回NULL
		return NULL;
	}
	else {
		if (T->lchild == p || T->rchild == p) { //T是p的双亲,返回T
			return T;
		}
		q = Parent_Tree(T->lchild, p);  //在左分支中查找
		if (q == NULL) {                //左分支中没有找到,查找右分支
			q = Parent_Tree(T->rchild, p);
			return q;
		}
		return q;
	}
}

BiTree LeftChild_Tree(BiTree T, BiTree p) //10、返回p的左孩子指针,若没有返回NULL
{
	if (T != NULL && p != NULL) {
		return p->lchild;
	}
	else {
		return NULL;
	}
}

BiTree RightChild_Tree(BiTree T, BiTree p) //11、返回p的右孩子指针,若没有返回NULL
{
	if (T != NULL && p != NULL) {
		return p->rchild;
	}
	else {
		return NULL;
	}
}

BiTree LeftBrother_Tree(BiTree T, BiTree p) //12、返回p的左兄弟指针,若没有返回NULL
{
	if (T == NULL) {
		return NULL;
	}
	else {
		BiTree q = Parent_Tree(T, p);   //先找到双亲结点
		if (q != NULL && q->lchild != p) {
			return q->lchild;
		}
		else {
			return NULL;
		}
	}
}

BiTree RightBrother_Tree(BiTree T, BiTree p) //13、返回p的右兄弟指针,若没有返回NULL
{
	if (T == NULL) {
		return NULL;
	}
	else {
		BiTree q = Parent_Tree(T, p);
		if (q != NULL && q->rchild != p) {
			return q->rchild;
		}
		else {
			return NULL;
		}
	}
}

void PrePrint_Tree(BiTree T)  //14、先序遍历并打印
{
	if (T != NULL) {
		cout << T->data;     //访问根节点
		PrePrint_Tree(T->lchild); //先序遍历左子树
		PrePrint_Tree(T->rchild); //先序遍历右子树
	}
}

void InPrint_Tree(BiTree T)  //15、中序遍历并打印
{
	if (T != NULL) {
		InPrint_Tree(T->lchild);  //中序遍历左子树
		cout << T->data;          //访问根节点
		InPrint_Tree(T->rchild);  //中序遍历右子树
	}
}

void PostPrint_Tree(BiTree T)  //16、后序遍历并打印
{
	if (T != NULL) {
		PostPrint_Tree(T->lchild); //后序遍历左子树
		PostPrint_Tree(T->rchild); //后序遍历右子树
		cout << T->data;          //访问根节点
	}
}

void LevelPrint_Tree(BiTree T)  //17、层次遍历并打印
{
	BiTree p;
	queue<BiTree>qu;  //定义队列,存放二叉树结点指针(这里使用了STL的queue类型)
	qu.push(T);       //根节点入队
	while (!qu.empty()) {
		p = qu.front();
		cout << p->data;  //访问队首结点
		qu.pop();         //队首结点出队
		if (p->lchild != NULL) {
			qu.push(p->lchild);  //若结点有左孩子,则左孩子入队
		}
		if (p->rchild != NULL) {
			qu.push(p->rchild);  //若结点有右孩子,则左孩子入队
		}
	}
}

void Assign_Tree(BiTree& T, BiTree p, char c) //18、将p结点元素赋值为c
{
	if (T == NULL || p == NULL) {
		return;
	}
	else {
		p->data = c;
	}
}

void Insert_Tree(BiTree& T, BiTree p, int LR, BiTree c) //19、插入(c为非空二叉树,且右子树为空)
{
	if (T == NULL || p == NULL || c == NULL) {
		return;
	}
	else {
		if (LR == 0) { //LR为0,则c作为p的左子树;为1,则c作为p的右子树
			c->rchild = p->lchild; //把原来的左子树连接在c的右子树上
			p->lchild = c;
		}
		else {
			c->rchild = p->rchild; //把原来的右子树连接在c的右子树上
			p->rchild = c;
		}
	}
}

void Delete_Tree(BiTree& T, BiTree p, int LR)  //20、删除子树
{
	if (T == NULL || p == NULL) {
		return;
	}
	if (LR == 0) { //删除p的左子树
		Destroy_Tree(p->lchild);
		p->lchild = NULL;
	}
	else {  //删除p的右子树
		Destroy_Tree(p->rchild);
		p->rchild = NULL;
	}
}

BiTree Find_Tree(BiTree T, char c)  //21、先序查找指定元素值的二叉树结点
{
	BiTree p = NULL;
	if (T == NULL) {
		return NULL;
	}
	else if (T->data == c) {  //访问的当前结点值等于c,返回当前指针,查找结束
		return T;
	}
	else {
		p = Find_Tree(T->lchild, c);  //在左分支中先序查找
		if (p == NULL) {
			p = Find_Tree(T->rchild, c); //左分支中未找到,继续先序查找右分支
			return p; //返回右分支查找结果
		}
		return p; //左分支中找到,返回当前指针,查找结束
	}
}

int main()
{
	BiTree T;
	Init_Tree(T);                //1、初始化
	bool t = Empty_Tree(T);      //5、判空
	if (t) {
		cout << "二叉树为空" << endl;
	}
	else {
		cout << "二叉树非空" << endl;
	}
	cout << "按先序顺序输入元素:";
	Create_Tree(T);              //3、创建
	int d = Depth_Tree(T);       //6、返回深度
	cout << "二叉树的深度:" << d << endl;
	char c = Root_Tree(T);       //7、返回根的元素值
	cout << "根的元素值为:" << c << endl;
	BiTree p, q;  //p为检验程序时使用,可随意更改p的指向
	cout << "请设置p指针指向的元素:";
	cin >> c;
	p = Find_Tree(T, c);         //21、先序查找指定元素值的二叉树结点
	c = Value_Tree(T, p);        //8、返回p指针指向的结点值
	cout << "p指向的结点值:" << c << endl;
	q = Parent_Tree(T, p);       //9、若p非T的根节点,则返回其双亲指针,否则返回NULL
	cout << "p的双亲指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = LeftChild_Tree(T, p);    //10、返回p的左孩子指针,若没有返回NULL
	cout << "p的左孩子指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = RightChild_Tree(T, p);   //11、返回p的右孩子指针,若没有返回NULL
	cout << "p的右孩子指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = LeftBrother_Tree(T, p);  //12、返回p的左兄弟指针,若没有返回NULL
	cout << "p的左兄弟指针q指向的元素:" << Value_Tree(T, q) << endl;
	q = RightBrother_Tree(T, p); //13、返回p的右兄弟指针,若没有返回NULL
	cout << "p的右兄弟指针q指向的元素:" << Value_Tree(T, q) << endl;
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	cout << "中序遍历二叉树:";
	InPrint_Tree(T);             //15、中序遍历并打印
	cout << endl;
	cout << "后序遍历二叉树:";
	PostPrint_Tree(T);           //16、后序遍历并打印
	cout << endl;
	cout << "层次遍历二叉树:";
	LevelPrint_Tree(T);          //17、层次遍历并打印
	cout << endl;
	cout << "想要更改的元素值:";
	cin >> c;
	q = Find_Tree(T, c);         //21、先序查找指定元素值的二叉树结点
	cout << "更改后的元素值:";
	cin >> c;
	Assign_Tree(T, q, c);        //18、将p结点元素赋值为c
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	BiTree S;  //另创建一个根节点右子树为空的二叉树,作为插入的样本
	Init_Tree(S);                //1、初始化
	cout << "按先序顺序输入要插入的二叉树(根节点右子树为空)的元素:";
	Create_Tree(S);              //3、创建
	int LR;
	cout << "请选择要插入的部位(0.p的左子树 1.p的右子树):";
	cin >> LR;
	Insert_Tree(T, p, LR, S);    //19、插入(S为非空二叉树,且右子树为空)
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	cout << "请选择要删除的部位(0.p的左子树 1.p的右子树):";
	cin >> LR;
	Delete_Tree(T, p, LR);       //20、删除子树
	cout << "先序遍历二叉树:";
	PrePrint_Tree(T);            //14、先序遍历并打印
	cout << endl;
	cout << "二叉树已清空" << endl;
	Clear_Tree(T);               //4、清空(释放根之外的空间)
	t = Empty_Tree(T);           //5、判空
	if (t) {
		cout << "二叉树为空" << endl;
	}
	else {
		cout << "二叉树非空" << endl;
	}
	Destroy_Tree(T);             //2、销毁(基于后序顺序)
	cout << "二叉树已销毁" << endl;
	return 0;
}

测试结果: 

二叉树为空
按先序顺序输入元素:ABD#G###CE##F##
二叉树的深度:4
根的元素值为:A
请设置p指针指向的元素:C
p指向的结点值:C
p的双亲指针q指向的元素:A
p的左孩子指针q指向的元素:E
p的右孩子指针q指向的元素:F
p的左兄弟指针q指向的元素:B
p的右兄弟指针q指向的元素:#
先序遍历二叉树:ABDGCEF
中序遍历二叉树:DGBAECF
后序遍历二叉树:GDBEFCA
层次遍历二叉树:ABCDEFG
想要更改的元素值:D
更改后的元素值:X
先序遍历二叉树:ABXGCEF
按先序顺序输入要插入的二叉树(根节点右子树为空)的元素:HJK####
请选择要插入的部位(0.p的左子树 1.p的右子树):0
先序遍历二叉树:ABXGCHJKEF
请选择要删除的部位(0.p的左子树 1.p的右子树):0
先序遍历二叉树:ABXGCF
二叉树已清空
二叉树为空
二叉树已销毁

以上是我个人的学习成果,很高兴能与大家分享。文章来源地址https://www.toymoban.com/news/detail-419276.html

到了这里,关于二叉树的基本操作(共21个)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 数据结构:二叉树的基本操作(用递归实现)

             本文将通过完成以下内容来展示二叉树的基本操作,代码解释标注全面而且清晰,代码书写也十分规范,适合初学者进行学习,本篇文章算是本人的一些学习记录分享,希望对有需要的小伙伴提供一些帮助~ 本文的内容为: 用递归的方法实现以下算法: 1.以二叉

    2024年02月06日
    浏览(49)
  • 【数据结构】二叉树的构建与基本操作实现

    👀 樊梓慕: 个人主页   🎥 个人专栏: 《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》 🌝 每一个不曾起舞的日子,都是对生命的辜负 目录 前言 1.前序建立二叉树 2.销毁二叉树 3.统计 4.查找值为x的节点 5.前中后序遍历 6.层序遍历 7.判断二叉树是否

    2024年02月07日
    浏览(43)
  • 深入理解数据结构第三弹——二叉树(3)——二叉树的基本结构与操作

    二叉树(1): 深入理解数据结构第一弹——二叉树(1)——堆-CSDN博客 二叉树(2): 深入理解数据结构第二弹——二叉树(2)——堆排序及其时间复杂度-CSDN博客 前言: 在前面我们讲了堆及其应用,帮助我们初步了解了二叉树的一些原理,但那与真正的二叉树仍有不同,

    2024年04月09日
    浏览(47)
  • 【数据结构】二叉树的存储与基本操作的实现

    二叉树的存储结构分为: 顺序存储 和类似于 链表的链式存储 这里博主讲一下链式存储 二叉树的链式存储是通过一个一个的节点引用起来的,常见的表示方式有 二叉和三叉 表示方式 二叉表示: 三叉表示: 这里博主主要讲解一下孩子表示法 在学习二叉树的基本操作前,需

    2024年02月04日
    浏览(46)
  • 数据结构实验报告,二叉树的基本操作(C语言)

    作者:命运之光 专栏:数据结构 实验六 二叉树的基本操作 实验环境:Visual C++或Dev C++ 实验目的: 1、掌握二叉树创建; 2、掌握二叉树的遍历及常用算法。 实验内容: 通过完全前序序列创建一棵二叉树,完成如下功能: 1)输出二叉树的前序遍历序列; 2)输出二叉树的中序遍

    2024年02月09日
    浏览(36)
  • 二叉树的基本操作-C语言实现-数据结构作业

    目录  (1)二叉树的创建; (2)二叉树的先序、中序和后序遍历输出; (3)输出二叉树的叶子节点和度为2的节点的数量; (4)输出二叉树的深度; (5)将二叉树所有节点的左右子树互换(左子树变右子树,右子树变左子树); (6)参考书上,二叉树按层次输出(一行输出一层); (7)删除二

    2024年02月04日
    浏览(46)
  • 数据结构和算法学习记录——初识二叉树(定义、五种基本形态、几种特殊的二叉树、二叉树的重要性质、初识基本操作函数)

    目录 二叉树的定义 二叉树具体的五种基本形态 1.空树 2.只有一个节点 3.有左子树,但右子树为空 4.有右子树,但左子树为空  5.左右两子树都不为空 特殊二叉树 斜二叉树 满二叉树  完全二叉树 二叉树的几个重要性质 初识二叉树的几个操作函数  二叉树T: 一个有穷的节点

    2024年02月03日
    浏览(60)
  • 吐血整理 二叉树(链表实现)的基本操作详解!

    本文是对二叉树这种数据结构基本操作与部分练习题的总结,内容庞大、详细、易懂,是你学习路上不容错过的优质博客! 既然是 链式二叉树 ,那必须得有自己的结点类型,以下是链式二叉树结点类型的定义,为了避免过多重复的代码,下面的问题都统一使用该结点类型。

    2024年02月03日
    浏览(57)
  • 【数据结构】_7.二叉树概念与基本操作

    目录 1.树形结构 1.1 树的概念 1.2 树的相关概念 1.3 树的表示 1.4 树在实际中的应用—表示文件系统的目录树结构 ​编辑​2.二叉树 2.1 概念 2.2 特殊二叉树  2.3 二叉树的性质 2.4 二叉树的存储结构 2.4.1 顺序存储结构(数组存储结构) 2.4.2 链式存储结构 2.5 二叉树的基本操作 2

    2024年02月12日
    浏览(38)
  • 二叉排序树的定义及基本操作(构造、查找、插入、删除)递归及非递归算法

    二叉排序树(Binary Sort Tree, BST),也称二叉查找树。 二叉排序树或者是一棵空树,或者是一棵具有下列特性的非空二叉树: 1) 若左子树非空,则左子树上所有结点均小于根结点的值; 2) 若右子树非空,则右子树上所有结点均大于根结点的值;

    2024年02月08日
    浏览(58)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包