数据结构二叉树创建及例题(上)

最新推荐文章于 2024-08-16 15:37:16 发布
最新推荐文章于 2024-08-16 15:37:16 发布
阅读量1.1k 收藏 17
点赞数 20
分类专栏： 数据结构与算法 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55383558/article/details/135557248
版权

今天就带领大家来到树的世界,树无论是在考试上还是实际学习方面都是比较重点的,大家在这块知识要花时间搞懂.

文章目录

前言

一、树的二叉链表定义

二、二叉树三种遍历方式(递归方式)

1.先序遍历方式(根左右)

2.中序遍历方式(左根右)

 3.后序遍历方式(左右根)

三、二叉树的层次遍历方式(采用数组模拟队列)

四、已知一颗二叉树的先序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表

五、已知一颗二叉树的后序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表

六、已知一颗二叉树的层序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表

七、二叉树的基本操作

1.求一颗二叉树的节点个数

2.求一棵二叉树的叶子节点个数

 3.求一棵二叉树中度为1的节点个数

 4.查找二叉树中值为x的节点,若存在则返回存储位置,不存在则返回空值

5.求一棵二叉树的高度

6.求一棵二叉树中值为x的节点作为根节点的子树的深度.

7.交换一棵二叉树的左右子树

8.判断两棵树是否相似(长得一样)

9.判断一棵树是否为完全二叉树

10.设计算法利用叶子节点中的的空指针域将所有的叶子节点,链接成一个带头节点的双链表

 11.一个包含二元运算的算数表达式以二叉链表形式存在在二叉树T中,设计算法求解算数表达式

 12.求一棵二叉树的最大宽度

八、总代码与测试结果

前言

树这块的内容比较多,包括树的一些基本的定义以及一些计算,后面还有完全二叉树,排序二叉树,平衡二叉树,这些树可能在定义上不一样但思想都是一样的,平衡二叉树在考试中主要考的是操作,代码实现的话实际上是比较困难的,但在面试时可能会考到,再后面树以及森林等等,后续都会讲到.这节主要是树的基本操作.

一、树的二叉链表定义

typedef char Elemtype;
//树的数据结构二叉链表
typedef struct BiTNode {
	Elemtype data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode,*BiTree;

二、二叉树三种遍历方式(递归方式)

1.先序遍历方式(根左右)

//二叉树的先序遍历(根左右)
void preorderTraverse(BiTree T) {
	if (T != NULL) {
		printf("%c ", T->data);//先访问根节点
		preorderTraverse(T->lchild);//遍历左子树
		preorderTraverse(T->rchild);//遍历右子树
	}
}

2.中序遍历方式(左根右)

//二叉树的中序遍历(左根右)
void inorderTraverse(BiTree T) {
	if (T != NULL) {
		inorderTraverse(T->lchild);
		printf("%c ", T->data);
		inorderTraverse(T->rchild);
	}
}

 3.后序遍历方式(左右根)

//二叉树的后序遍历(左右根)
void postorderTraverse(BiTree T) {
	if (T != NULL) {
		postorderTraverse(T->lchild);
		postorderTraverse(T->rchild);
		printf("%c ", T->data);
	}
}

三、二叉树的层次遍历方式(采用数组模拟队列)

//二叉树的层次遍历算法
void levelTraverse(BiTree T) {//使用数组模拟队列注意分配长度
	BiTNode* Queue[80] = {NULL};//这里就分配了40注意
	int front = 0;
	int rear = 0;
	if (T != NULL) {
		Queue[++rear] = T;//根节点入队
	}
	while (front != rear) {
		BiTNode* p = Queue[++front];
		printf("%c ", p->data);
		if (p!=NULL && p->lchild != NULL) {
			Queue[++rear] = p->lchild;
		}
		if (p != NULL && p->rchild != NULL) {
			Queue[++rear] = p->rchild;
		}
	}
}

层次遍历序列为:ABCDEFG

算法思想:首先创建一个队列,将根节点先入队列,如果队列不为空循环操作

1.出队

2.有孩子将孩子入队

直到队列为空,遍历完成.

四、已知一颗二叉树的先序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表

这题也是建立二叉树的基本算法,自命题考试的时候容易考.

//已知一颗二叉树的先序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表
BiTNode* creatBitree1(char pre[], char in[], int l1, int h1, int l2, int h2) {
	//l代表第一个元素的位置,h代表最后一个元素的位置
	if (l1 > h1) {
		return NULL;
	}
	BiTNode* pNode = (BiTNode*)malloc(sizeof(BiTNode));
	assert(pNode);
	pNode->data = pre[l1];//在中序遍历中寻找根节点所在位置
	int p = l2;
	while (p <= h2) {
		if (in[p] == pre[l1]) {
			break;
		}
		p++;
	}
	//p为在数组中下标a减下标b表示a到b中有几个元素算a不算b
	pNode->lchild = creatBitree1(pre, in, l1 + 1, l1 + p - l2, l2, p - 1);
	pNode->rchild = creatBitree1(pre, in, l1 + p - l2 + 1, h1, p + 1, h2);
	return pNode;
}

算法思想:使用先序和中序序列构建二叉树,首先我们知道先序序列的第一个节点是跟节点,获得根节点后在中序遍历序列中找到根节点所在位置,那么就能确定左孩子和右孩子序列这样我们在根据先序遍历序列就又能递归的将树建立起来.

五、已知一颗二叉树的后序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表

//已知一颗二叉树的后序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表
BiTNode* creatBitree2(char post[], char in[], int l1, int h1, int l2, int h2) {
	if (l1 > h1) {
		return NULL;
	}
	BiTNode* pNode = (BiTNode*)malloc(sizeof(BiTNode));
	assert(pNode);
	pNode->data = post[h1];
	int p = l2;
	while (l2 <= h2) {
		if (in[p] == post[h1]) {
			break;
		}
		p++;
	}
	pNode->lchild = creatBitree2(post, in, l1, l1 + p - l2 - 1, l2, p - 1);
	pNode->rchild = creatBitree2(post, in, l1 + p - l2, h1 - 1, p + 1, h2);
	return pNode;
}

还是根据上图数据.

算法思想;使用后续遍历与中序遍历构建二叉树,首先我们知道后续遍历的最后的一个节点为根节点,这样我们在中序遍历中找到根节点所在位置,那么左子树右子树序列就知道了,再根据后续遍历的最后一个节点为根节点,就能够递归的建立二叉树了.

六、已知一颗二叉树的层序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表

//已知一颗二叉树的层序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表
BiTNode* creatBitree3(char level[], char in[], int l1, int h1, int l2, int h2) {
	if (l1 > h1) {
		return NULL;
	}
	BiTNode* pNode = (BiTNode*)malloc(sizeof(BiTNode));
	assert(pNode);
	pNode->data = level[l1];
	int p = l2;
	while (p <= h2) {
		if (in[p] == level[l1]) {
			break;
		}
		p++;
	}
	//寻找左子树和右子树在层次遍历中的顺序
	char lelflevel[5];
	char rightlevel[5];
	int lelflength = 0;
	int rightlength = 0;
	//左子树
	for (int i = l1 + 1; i <= h1; i++) {
		for (int j = l2; j < p; j++) {
			if (level[i] == in[j]) {
				lelflevel[lelflength] = level[i];
				lelflength++;
			}
		}
	}
	//右子树
	for (int i = l1 + 1; i <= h1; i++) {
		for (int j = p + 1; j <= h2; j++) {
			if (level[i] == in[j]) {
				rightlevel[rightlength] = level[i];
				rightlength++;
			}
		}
	}
	pNode->lchild = creatBitree3(lelflevel, in, 0, lelflength - 1, l2, p - 1);
	pNode->rchild = creatBitree3(rightlevel, in, 0, rightlength - 1, p + 1, h2);
	return pNode;
}

算法思想:使用层次遍历与中序遍历建立二叉树,首先我们知道先序遍历第一个节点为根节点,这样我们在中序遍历序列中找到根节点所在位置我们就能知道左子树和右子树的序列,但返回层次遍历序列在寻找左右子树序列时,与前两道题不同,由于层次遍历序列只能反映大概位置并不能直接反应左子树和右子树序列,所以我们需要寻找序列,在层次遍历中按顺序判断,该元素是否在左子树序列(或右子树序列)在就加入左子树(或右子树)层次遍历数组中这样我们就得到了,左子树和右子树的层次遍历序列,再根据中序遍历,这样就又能递归的建立二叉树了.

注意:这三种构建二叉树的方式不要先看代码,先不要研究这是怎么来的,先自己根据我所给的二叉树手推一遍,我愿成为上面二叉树的例子,是搞懂这几个算法之神.

七、二叉树的基本操作

1.求一颗二叉树的节点个数

//例1:求一颗二叉树的节点个数
int nodesInBitree(BiTree T) {//递归实现,采用先序遍历算法思想
	if (T == NULL) {
		return 0;
	}
	return 1 + nodesInBitree(T->lchild) + nodesInBitree(T->rchild);
}

2.求一棵二叉树的叶子节点个数

//例2:求一棵二叉树的叶子节点个数
int leafsInBitree(BiTree T) {//先序遍历的思想
	if (T == NULL) {
		return 0;
	}
	else if (T->lchild == NULL && T->rchild == NULL) {//叶子姐姐
		return 1;
	}
	return leafsInBitree(T->lchild) + leafsInBitree(T->rchild);
}

 3.求一棵二叉树中度为1的节点个数

//例3:求一棵二叉树中度为1的节点个数
int getsinglenodes(BiTree T) {//先序遍历的思想
	if (T == NULL) {
		return 0;
	}
	else if (T->lchild != NULL && T->rchild == NULL) {//左子树不为空继续搜索
		return 1 + getsinglenodes(T->lchild);
	}
	else if (T->lchild == NULL && T->rchild != NULL) {//右子树不为空继续搜索
		return 1 + getsinglenodes(T->rchild);
	}
	else {
		return getsinglenodes(T->lchild) + getsinglenodes(T->rchild);
	}
}

 4.查找二叉树中值为x的节点,若存在则返回存储位置,不存在则返回空值

//例4:查找二叉树中值为x的节点,若存在则返回存储位置,不存在则返回空值
BiTNode* seekElemNode(BiTree T,char x) {
	if (T == NULL) {
		return NULL;
	}
	else if (x == T->data) {
		return T;
	}
	else {
		BiTNode* tmp = seekElemNode(T->lchild,x);//搜左子树
		if (tmp != NULL) {
			return tmp;
		}
		else {//左子树没有
			return seekElemNode(T->rchild,x);//搜右子树
		}
	}
}

5.求一棵二叉树的高度

这个算法一定要熟悉,单独考它不多但它经常处理一些复杂算法中起到作用

//例5:求一棵二叉树的高度
int getBitreehigh(BiTree T) {//递归思想
	if (T == NULL) {
		return 0;
	}
	else {
		int lelfhigh = getBitreehigh(T->lchild);
		int righthigh = getBitreehigh(T->rchild);
		return lelfhigh > righthigh ? lelfhigh + 1 : righthigh + 1;
	}
}

6.求一棵二叉树中值为x的节点作为根节点的子树的深度.

算法思想就是例4和例5结合,先找到值为x的节点,在根据此节点求二叉树的高度

7.交换一棵二叉树的左右子树

//例7:交换一棵二叉树的左右子树
void switchLRchild(BiTree T) {
	if (T != NULL) {
		BiTNode* tmp = T->lchild;
		T->lchild = T->rchild;
		T->rchild = tmp;
		switchLRchild(T->lchild);
		switchLRchild(T->rchild);
	}
}

8.判断两棵树是否相似(长得一样)

//例8:判断两棵树是否相似(长得一样)
bool issimilarBitree(BiTree T1, BiTree T2) {
	if (T1 == NULL && T2 == NULL) {
		return true;
	}
	else if (T1 == NULL && T2 != NULL || T1 != NULL && T2 == NULL) {
		return false;
	}
	else {
		return issimilarBitree(T1->lchild, T2->lchild) && issimilarBitree(T1->rchild, T2->rchild);
	}
}

9.判断一棵树是否为完全二叉树

//例9:判断一棵树是否为完全二叉树
//算法思想:层序遍历树(将空孩子也入队)如果出队的节点为空,是完全二叉树那么队列中的结点都为空,如果有不为空的节点那么就不是完全二叉树
bool isCompleteBitree(BiTree T) {
	//应用数组模拟队列
	BiTNode* Queue[30];//注意这里数组队列的空间
	int front = 0;
	int rear = 0;
	if (T != NULL) {
		Queue[++rear] = T;
	}
	while (front != rear) {//层次遍历
		BiTNode* tmp = Queue[++front];
		if (tmp == NULL) {//遇到第一个空姐点退出循环
			break;
		}
		Queue[++rear] = tmp->lchild;
		Queue[++rear] = tmp->rchild;
	}
	while (front != rear) {//判断后续节点是否为空
		BiTNode *tmp = Queue[++front];
		if (tmp != NULL) {//有节点不为空说明不是完全二叉树
			return 0;
		}
	}
	return 1;
}

算法思想:层序遍历树(将空孩子也入队)如果出队的节点为空,是完全二叉树那么队列中的结点都为空,如果有不为空的节点那么就不是完全二叉树

10.设计算法利用叶子节点中的的空指针域将所有的叶子节点,链接成一个带头节点的双链表

//例10:设计算法利用叶子节点中的的空指针域将所有的叶子节点,链接成一个带头节点的双链表
void Linkleafs(BiTree T, BiTNode*& pTail) {//采用尾插法这样就不用判断插入的节点是否是第一个节点
	if (T != NULL) {
		if (T->lchild == NULL && T->rchild == NULL) {//叶子节点
			T->lchild = pTail;
			pTail->rchild = T;
			pTail = T;
		}
		else {
			Linkleafs(T->lchild,pTail);//处理左子树
			Linkleafs(T->rchild, pTail);//处理右子树
		}
	}
}
BiTNode* operatFunc(BiTree T) {
	BiTNode* L = NULL;
	L = (BiTNode*)malloc(sizeof(BiTNode));
	assert(L);
	L->lchild = NULL;
	L->rchild = NULL;
	BiTNode* pTail = L;
	Linkleafs(T, pTail);
	return L;
}
//打印双链表函数(数据类型char)
void print(BiTNode *L) {
	BiTNode* p = L->rchild;
	while (p) {
		printf("%c ", p->data);
		p = p->rchild;
	}
	printf("\n");
}

 11.一个包含二元运算的算数表达式以二叉链表形式存在在二叉树T中,设计算法求解算数表达式

//例11:一个包含二元运算的算数表达式以二叉链表形式存在在二叉树T中,设计算法求解算数表达式
int compute(char oprt, int leftnum, int rightnum) {//计算函数
	switch (oprt) {
	case'+':return leftnum + rightnum; break;
	case'-':return leftnum - rightnum; break;
	case'*':return leftnum * rightnum; break;
	case'/':return leftnum / rightnum; break;
	}
}
int getnum(BiTree T) {
	if (T == NULL) {//树为空
		return 0;
	}
	else if (T->lchild != NULL && T->rchild != NULL) {//操作符节点
		char oprt = T->data;
		int leftnum = getnum(T->lchild);
		int rightnum = getnum(T->rchild);
		return compute(oprt, leftnum, rightnum);//递归求值
	}
	else {//操作树节点
		return T->data - '0';
	}

}
//创建一棵算数表达式树
BiTNode* creatoprtBitree() {
	char pre[7] = { '-','+','2','1','/','4','2' };
	char in[7] = { '2','+','1','-','4','/','2' };
	return creatBitree1(pre, in, 0, 6, 0, 6);
}

 12.求一棵二叉树的最大宽度

//例12:求一棵二叉树的最大宽度
//这里直接用了一个数组直接存储每层的宽度
void getWidthBitree(BiTree T, int level,int wid[],int &max) {
	if (T == NULL) return;
	wid[level]++;
	if (wid[level] > max) max = wid[level];
	getWidthBitree(T->lchild, level + 1,wid,max);
	getWidthBitree(T->rchild, level + 1,wid,max);
}

八、总代码与测试结果

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#define MAX 20
typedef char Elemtype;
//树的数据结构二叉链表
typedef struct BiTNode {
	Elemtype data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode,*BiTree;
//二叉树的先序遍历(根左右)
void preorderTraverse(BiTree T) {
	if (T != NULL) {
		printf("%c ", T->data);
		preorderTraverse(T->lchild);
		preorderTraverse(T->rchild);
	}
}
//二叉树的中序遍历(左根右)
void inorderTraverse(BiTree T) {
	if (T != NULL) {
		inorderTraverse(T->lchild);
		printf("%c ", T->data);
		inorderTraverse(T->rchild);
	}
}
//二叉树的后序遍历(左右根)
void postorderTraverse(BiTree T) {
	if (T != NULL) {
		postorderTraverse(T->lchild);
		postorderTraverse(T->rchild);
		printf("%c ", T->data);
	}
}
//二叉树的层次遍历算法
void levelTraverse(BiTree T) {//使用数组模拟队列
	BiTNode* Queue[80] = {NULL};//这里就分配了40注意
	int front = 0;
	int rear = 0;
	if (T != NULL) {
		Queue[++rear] = T;//根节点入队
	}
	while (front != rear) {
		BiTNode* p = Queue[++front];
		printf("%c ", p->data);
		if (p!=NULL && p->lchild != NULL) {
			Queue[++rear] = p->lchild;
		}
		if (p != NULL && p->rchild != NULL) {
			Queue[++rear] = p->rchild;
		}
	}
}
//已知一颗二叉树的先序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表
BiTNode* creatBitree1(char pre[], char in[], int l1, int h1, int l2, int h2) {
	//l代表第一个元素的位置,h代表最后一个元素的位置
	if (l1 > h1) {
		return NULL;
	}
	BiTNode* pNode = (BiTNode*)malloc(sizeof(BiTNode));
	assert(pNode);
	pNode->data = pre[l1];
	int p = l2;
	while (p <= h2) {
		if (in[p] == pre[l1]) {
			break;
		}
		p++;
	}
	//在数组中下标a减下标b表示a到b中有几个元素算a不算b
	pNode->lchild = creatBitree1(pre, in, l1 + 1, l1 + p - l2, l2, p - 1);
	pNode->rchild = creatBitree1(pre, in, l1 + p - l2 + 1, h1, p + 1, h2);
	return pNode;
}
//已知一颗二叉树的后序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表
BiTNode* creatBitree2(char post[], char in[], int l1, int h1, int l2, int h2) {
	if (l1 > h1) {
		return NULL;
	}
	BiTNode* pNode = (BiTNode*)malloc(sizeof(BiTNode));
	assert(pNode);
	pNode->data = post[h1];
	int p = l2;
	while (l2 <= h2) {
		if (in[p] == post[h1]) {
			break;
		}
		p++;
	}
	pNode->lchild = creatBitree2(post, in, l1, l1 + p - l2 - 1, l2, p - 1);
	pNode->rchild = creatBitree2(post, in, l1 + p - l2, h1 - 1, p + 1, h2);
	return pNode;
}
//已知一颗二叉树的层序遍历序列和中序遍历分别存在两个一维数组中试编写算法建立该二叉树的二叉链表
BiTNode* creatBitree3(char level[], char in[], int l1, int h1, int l2, int h2) {
	if (l1 > h1) {
		return NULL;
	}
	BiTNode* pNode = (BiTNode*)malloc(sizeof(BiTNode));
	assert(pNode);
	pNode->data = level[l1];
	int p = l2;
	while (p <= h2) {
		if (in[p] == level[l1]) {
			break;
		}
		p++;
	}
	//寻找左子树和右子树在层次遍历中的顺序
	char lelflevel[5];
	char rightlevel[5];
	int lelflength = 0;
	int rightlength = 0;
	//左子树
	for (int i = l1 + 1; i <= h1; i++) {
		for (int j = l2; j < p; j++) {
			if (level[i] == in[j]) {
				lelflevel[lelflength] = level[i];
				lelflength++;
			}
		}
	}
	//右子树
	for (int i = l1 + 1; i <= h1; i++) {
		for (int j = p + 1; j <= h2; j++) {
			if (level[i] == in[j]) {
				rightlevel[rightlength] = level[i];
				rightlength++;
			}
		}
	}
	pNode->lchild = creatBitree3(lelflevel, in, 0, lelflength - 1, l2, p - 1);
	pNode->rchild = creatBitree3(rightlevel, in, 0, rightlength - 1, p + 1, h2);
	return pNode;
}
//二叉树的基本操作
//例1:求一颗二叉树的节点个数
int nodesInBitree(BiTree T) {
	if (T == NULL) {
		return 0;
	}
	return 1 + nodesInBitree(T->lchild) + nodesInBitree(T->rchild);
}
//例2:求一棵二叉树的叶子节点个数
int leafsInBitree(BiTree T) {
	if (T == NULL) {
		return 0;
	}
	else if (T->lchild == NULL && T->rchild == NULL) {//叶子姐姐
		return 1;
	}
	return leafsInBitree(T->lchild) + leafsInBitree(T->rchild);
}
//例3:求一棵二叉树中度为1的节点个数
int getsinglenodes(BiTree T) {
	if (T == NULL) {
		return 0;
	}
	else if (T->lchild != NULL && T->rchild == NULL) {//左子树不为空继续搜索
		return 1 + getsinglenodes(T->lchild);
	}
	else if (T->lchild == NULL && T->rchild != NULL) {//右子树不为空继续搜索
		return 1 + getsinglenodes(T->rchild);
	}
	else {
		return getsinglenodes(T->lchild) + getsinglenodes(T->rchild);
	}
}
//例4:查找二叉树中值为x的节点,若存在则返回存储位置,不存在则返回空值
BiTNode* seekElemNode(BiTree T,char x) {
	if (T == NULL) {
		return NULL;
	}
	else if (x == T->data) {
		return T;
	}
	else {
		BiTNode* tmp = seekElemNode(T->lchild,x);//搜左子树
		if (tmp != NULL) {
			return tmp;
		}
		else {//左子树没有
			return seekElemNode(T->rchild,x);//搜右子树
		}
	}
}
//例5:求一棵二叉树的高度
int getBitreehigh(BiTree T) {
	if (T == NULL) {
		return 0;
	}
	else {
		int lelfhigh = getBitreehigh(T->lchild);
		int righthigh = getBitreehigh(T->rchild);
		return lelfhigh > righthigh ? lelfhigh + 1 : righthigh + 1;
	}
}
//例6:求一棵二叉树中值为x的节点作为根节点的子树的深度
//算法思想就是例4和例5结合,先找到值为x的节点,在根据此节点求二叉树的高度



//例7:交换一棵二叉树的左右子树
void switchLRchild(BiTree T) {
	if (T != NULL) {
		BiTNode* tmp = T->lchild;
		T->lchild = T->rchild;
		T->rchild = tmp;
		switchLRchild(T->lchild);
		switchLRchild(T->rchild);
	}
}
//定义三种遍历函数
void Traverse(BiTree T) {
	printf("先序遍历结果:");
	preorderTraverse(T);
	printf("\n");
	printf("中序遍历结果:");
	inorderTraverse(T);
	printf("\n");
	printf("后序遍历结果:");
	postorderTraverse(T);
	printf("\n");
	printf("层序遍历结果:");
	levelTraverse(T);
	printf("\n");
}
//例8:判断两棵树是否相似(长得一样)
bool issimilarBitree(BiTree T1, BiTree T2) {
	if (T1 == NULL && T2 == NULL) {
		return true;
	}
	else if (T1 == NULL && T2 != NULL || T1 != NULL && T2 == NULL) {
		return false;
	}
	else {
		return issimilarBitree(T1->lchild, T2->lchild) && issimilarBitree(T1->rchild, T2->rchild);
	}
}
//例9:判断一棵树是否为完全二叉树
//算法思想:层序遍历树(将空孩子也入队)如果出队的节点为空,是完全二叉树那么队列中的结点都为空,如果有不为空的节点那么就不是完全二
//叉树
bool isCompleteBitree(BiTree T) {
	//应用数组模拟队列
	BiTNode* Queue[30];//注意这里数组队列的空间
	int front = 0;
	int rear = 0;
	if (T != NULL) {
		Queue[++rear] = T;
	}
	while (front != rear) {//层次遍历
		BiTNode* tmp = Queue[++front];
		if (tmp == NULL) {//遇到第一个空姐点退出循环
			break;
		}
		Queue[++rear] = tmp->lchild;
		Queue[++rear] = tmp->rchild;
	}
	while (front != rear) {//判断后续节点是否为空
		BiTNode *tmp = Queue[++front];
		if (tmp != NULL) {//有节点不为空说明不是完全二叉树
			return 0;
		}
	}
	return 1;
}
//创建一棵完全二叉树
BiTNode* creatCompleteBitree() {
	char pre[7] = { 'A','B','D','E','C','F','G'};//先
	char in[7] = { 'D','B','E','A','F','C','G'};//中
	return creatBitree1(pre, in, 0, 6, 0, 6);
}
//例10:设计算法利用叶子节点中的的空指针域将所有的叶子节点,链接成一个带头节点的双链表
void Linkleafs(BiTree T, BiTNode*& pTail) {//采用尾插法这样就不用判断插入的节点是否是第一个节点
	if (T != NULL) {
		if (T->lchild == NULL && T->rchild == NULL) {//叶子节点
			T->lchild = pTail;
			pTail->rchild = T;
			pTail = T;
		}
		else {
			Linkleafs(T->lchild,pTail);//处理左子树
			Linkleafs(T->rchild, pTail);//处理右子树
		}
	}
}
BiTNode* operatFunc(BiTree T) {
	BiTNode* L = NULL;
	L = (BiTNode*)malloc(sizeof(BiTNode));
	assert(L);
	L->lchild = NULL;
	L->rchild = NULL;
	BiTNode* pTail = L;
	Linkleafs(T, pTail);
	return L;
}
//打印双链表函数(数据类型char)
void print(BiTNode *L) {
	BiTNode* p = L->rchild;
	while (p) {
		printf("%c ", p->data);
		p = p->rchild;
	}
	printf("\n");
}
//例11:一个包含二元运算的算数表达式以二叉链表形式存在在二叉树T中,设计算法求解算数表达式
int compute(char oprt, int leftnum, int rightnum) {//计算函数
	switch (oprt) {
	case'+':return leftnum + rightnum; break;
	case'-':return leftnum - rightnum; break;
	case'*':return leftnum * rightnum; break;
	case'/':return leftnum / rightnum; break;
	}
}
int getnum(BiTree T) {
	if (T == NULL) {//树为空
		return 0;
	}
	else if (T->lchild != NULL && T->rchild != NULL) {//操作符节点
		char oprt = T->data;
		int leftnum = getnum(T->lchild);
		int rightnum = getnum(T->rchild);
		return compute(oprt, leftnum, rightnum);//递归求值
	}
	else {//操作树节点
		return T->data - '0';
	}

}
//创建一棵算数表达式树
BiTNode* creatoprtBitree() {
	char pre[7] = { '-','+','2','1','/','4','2' };
	char in[7] = { '2','+','1','-','4','/','2' };
	return creatBitree1(pre, in, 0, 6, 0, 6);
}
//例12:求一棵二叉树的最大宽度

void getWidthBitree(BiTree T, int level,int wid[],int &max) {
	if (T == NULL) return;
	wid[level]++;
	if (wid[level] > max) max = wid[level];
	getWidthBitree(T->lchild, level + 1,wid,max);
	getWidthBitree(T->rchild, level + 1,wid,max);
}
int main() {
	char pre[5] = { 'A','B','D','C','E' };//先
	char in[5] = { 'D','B','A','C','E' };//中
	char post[5] = { 'D','B','E','C','A' };//后
	char level[5] = { 'A','B','C','D','E' };//层
	int prelength = sizeof(pre) / sizeof(pre[0]);
	int postlength = sizeof(post) / sizeof(post[0]);
	int levellength = sizeof(level) / sizeof(level[0]);
	int inlength = sizeof(in) / sizeof(in[0]);
	//BiTree T = creatBitree1(pre, in, 0, prelength - 1, 0, inlength - 1);//先序和中序
	//BiTree T = creatBitree2(post, in, 0, postlength - 1, 0, inlength - 1);//后序和中序
	BiTree T = creatBitree3(level, in, 0, levellength - 1, 0, inlength - 1);//层序和中序
	BiTree Ttest = creatBitree3(level, in, 0, levellength - 1, 0, inlength - 1);//层序和中序
	Traverse(T);
	printf("该二叉树的节点个数为:%d\n", nodesInBitree(T));
	printf("该二叉树的叶子节点个数为:%d\n", leafsInBitree(T));
	printf("该二叉树的度为1节点个数为:%d\n", getsinglenodes(T));
	printf("查找的节点为:%c\n", seekElemNode(T, 'C')->data);
	printf("该二叉树的高度为:%d\n", getBitreehigh(T));
	printf("以B为根的子树的高度为:%d\n", getBitreehigh(seekElemNode(T, 'B')));
	printf("++++++++++++++++++++++++++++++++++++\n");
	printf("交换左右子树\n");
	printf("交换子树前\n");
	Traverse(Ttest);
	switchLRchild(Ttest);
	printf("交换子树后\n");
	Traverse(Ttest);
	printf("判断T与Ttest两棵树是否相似(相似返回1,不相似返回0):%d\n", issimilarBitree(T, Ttest));
	printf("判断二叉树T是否为一棵完全二叉树(是返回1,不是返回0):%d\n", isCompleteBitree(T));
	printf("创建一棵完全二叉树\n");
	BiTree TC = creatCompleteBitree();
	Traverse(TC);
	printf("判断二叉树TC是否为一棵完全二叉树(是返回1,不是返回0):%d\n", isCompleteBitree(TC));
	printf("++++++++++++++++++++++++++++++++++++\n");
	printf("利用叶子节点中的的空指针域将所有的叶子节点,链接成一个带头节点的双链表\n");
	BiTNode* L = operatFunc(TC);
	print(L);
	printf("++++++++++++++++++++++++++++++++++++\n");
	printf("创建一棵算数表达式树\n");
	BiTNode* TO = creatoprtBitree();
	Traverse(TO);
	printf("该算数表达式的值为:%d\n", getnum(TO));
	int wid[20] = { 0 };
	int max = 0;
	getWidthBitree(T, 1,wid,max);
	printf("二叉树TC的最大宽度为:%d\n", max);
	printf("注意后续不要在使用TC,因为TC已经将叶子节点转变为双链表!!!!!!!!\n");
	return 0;
}

笔写落去
关注
专栏目录
【数据结构】—二叉树遍历
四季轮换叶，一路招摇胜
05-01 1141
树是由n(n>=0)个结点所构成的有限集合。对于一颗非空树，其中有且仅有一个没有前驱的结点，这个结点就是【根节点】，其余结点有且仅有一个前驱，但可以有多个后继。今天讲解一下二叉树的三种遍历方法...
数据结构-例题实训作业-二叉树相关
Junds0的博客
11-07 915
本关任务：以先序的方式建立二叉树后，补充代码，统计该二叉树的节点数，叶子数，满节点数，计算数的高度。本关任务：以先序的方式建立二叉树后，补充代码，完成对该二叉树的先序遍历，中序遍历和后序遍历。本关任务：以先序的方式建立二叉树后，补充代码，在二叉树中查找某节点是否存在。请按先序顺序依次输入树的节点（包括空节点，以#表示）请按先序顺序依次输入树的节点（包括空节点，以#表示）请按先序顺序依次输入树的节点（包括空节点，以#表示）在以下空白处补写代码，以先序方式完成二叉树的建立。在以下空白处补写代码，完成任务要求。
【数据结构】二叉树的创建
xiaoxiaoguailou的博客
03-20 3145
文章目录二叉树的创建与遍历创建方式一创建方式二：先序+中序创建方式三：中序+后序 二叉树的创建与遍历 以下图的二叉树为例： Binary_Tree.h #ifndef BINARY_TREE_H #define BINARY_TREE_H typedef char Element; //二叉链式树节点 typedef struct BtNode { Element data; //数据域 struct BtNode* leftchild; //左孩子 struct BtNode* right
二叉树的经典例题（干货满满附源码）
最新发布
qq_63074244的博客
08-16 341
上述例题均是利用了递归进行二叉树问题的解决，虽然思路不是很难但是自己上手还是有一点问题，值的我们自己进行上手练习一下。
数据结构——创建二叉树
06-04
以二叉链表为存储结构，实现二叉树的创建、遍历（先序，中序，后序遍历）算法
数据结构之二叉树的创建
业精于勤荒于嬉
05-07 4498
创建二叉树 首先定义相关结构体及其他变量 #define BT_LEFT 0 // 左边 #define BT_RIGHT 1 // 右边 // 定义新数据类型，用于封装函数 typedef void BTree; typedef unsigned long long BTPos; // 定义二叉树左右指针结构体 typedef struct _tag_BTreeNode BTreeNode; struct _tag_BTreeNode { BT...
数据结构与算法（三） 03-平衡二叉树及二叉树的经典题型
一只蒻蒻的博客
01-08 823
平衡二叉树、二叉树的经典题 1 平衡二叉树 题目 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 平衡二叉树：每个子树的深度之差不超过1 思路 后续遍历二叉树，在遍历二叉树每个节点前都会遍历其左右子树 比较左右子树的深度，若差值>1则返回一个标记-1表示当前子树不平衡 若左右子树存在一个不平衡或左右子树差值大于1，则整棵树不平衡 若左右子树平衡，则返回当前树深：左右子树最大深度+1 代码 function IsBalanced_Solution(pRoot) { retur
【数据结构】二叉树详解
qq_52989768的博客
08-20 4828
树是一种非线性的数据结构，是由多个节点组成的有层次关系的集合，看起来就像一颗倒挂的树，如下图：树中有一个节点没有前驱节点，这个节点称为根节点除根节点外，其余的节点又可以看成多个互不相交的集合，每一个集合就是一颗子树。
数据结构-第五期——二叉树（Python）
荷叶田田的博客
12-21 4220
二叉树满足条件：1、本身是有序树 2、树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2；
数据结构程序二叉树的建立
01-02
我自己亲身检验··源代码，报告详细，内容详尽
数据结构二叉树的创建
10-24
数据结构二叉树的创建，使用二级指针完成二叉树的创建的同时又用引用类型实现了二叉树的创建！
数据结构建立二叉树（二叉建立树）
06-14
数据结构 VC++ 建立二叉树 内带完善插入，删除，修改，统计所有节点等的信息！
数据结构之创建二叉树
weixin_34390105的博客
12-01 190
例如 str---A(B(D(,G)),C,(E,F))扫描采用括号表示法表示二叉树的字符串 读到的符号为ch使用一个栈保存双亲结点引入一个变量k 作用是指定其后处理的是左孩子还是右孩子k=1 处理左孩子 k=2 处理右孩子情况如下遇到一个实实在在的字母时创建一个节点1 遇到 ch=左括号 将前面创建的结点作为父节点进栈，置k=1,表示其后的结点将作为这个节点的左孩子2 ...
数据结构---二叉树的建立
不停
10-10 484
//1，二叉树的定义 //2.利用先序遍历创建二叉树，同理，用该方法可以以中序遍历，后序遍历创建二叉树 typedef struct Node { DataType data; struct Node *leftchild; struct Node *rightchild; }BiTnode,*BiTree; //先序遍历 void CreateBiTree(BiTree *bt) { c...
数据结构【二叉树】 二叉树的创建
Kelisiya
07-12 860
#include using namespace std; class Node{ public: int data; Node *lchild , *rchild; Node(int _data){ data = _data; lchild = NULL; rchild = NULL; } }; class
数据结构--创建二叉树
GP的空间
05-14 1141
通过录入一个前序排列的结构，shengc
数据结构左倾堆的例题
03-28
左倾堆是一种特殊的二叉堆，它具有以下特点： 1. 左倾堆是一棵二叉树，每个节点除了存储数据外，还包含一个左右子树的距离值（也称为零路径长）。 2. 左倾堆满足左倾性质，即任意节点的左子树的距离值大于等于右子树的距离值。 3. 左倾堆的根节点存储的数据是堆中的最小值（或最大值，具体取决于实现）。 下面以一个例题来介绍左倾堆的应用： 假设有一个任务队列，每个任务有一个优先级。我们需要实现一个数据结构来管理这个任务队列，并能够高效地完成以下操作： 1. 插入一个任务。 2. 删除优先级最高的任务。 我们可以使用左倾堆来实现这个任务队列。具体步骤如下： 1. 定义左倾堆的节点结构，包含任务的优先级和其他必要的信息。 2. 实现插入操作： - 创建一个新节点，将任务的优先级和其他信息存储在节点中。 - 将新节点与当前左倾堆合并，得到一个新的左倾堆。 3. 实现删除操作： - 找到左倾堆中优先级最高的节点，即根节点。 - 将根节点的左子树和右子树合并，得到一个新的左倾堆。 左倾堆的插入和删除操作的时间复杂度均为O(log n)，其中n为堆中节点的数量。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

笔写落去

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值