数据结构——二叉树的应用

已于 2023-12-17 17:13:03 修改
阅读量67 收藏
点赞数
文章标签： 数据结构 算法 c语言
于 2023-12-17 16:36:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FLY_LZL/article/details/135046484
版权

 一、主要内容

（1）二叉树的二叉链表的创建

（2）二叉树的前、中、后序遍历的递归算法

（3）求二叉树中叶子结点数目的递归算法

（4）编写二叉树中位于后序序列第k个结点的值的算法

（5）编写算法删除二叉树中所有以值为x的结点为根的子树并释放相应空间

（6）二叉树的前/中/后序遍历的非递归算法的实现

（7）编写二叉树层序遍历的算法

二、整体代码

#include<stdio.h>
#include<stdlib.h>


//实验五
#define MAX_TREE_SIZE 100
typedef char ElemType;
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
	int flag;
}BiTNode, *BiTree;
void CreateBiTree(BiTree* T)
{
	char c;
	printf("请输入该结点的元素(输入','表示停止在该根结点下创建子树)：");
	getchar();
	scanf("%c", &c);
	if (c == ',')
	{
		*T = NULL;
		return;//printf("构造了一个空树\n");
	}
	else
	{
		if (!(*T = (BiTree)malloc(sizeof(BiTNode))))
			return;//printf("OVERFLOW\n");
		else
		{
			(*T)->data = c;
			//printf("%c\n", (*T)->data);
			//printf("left ");
			CreateBiTree(&((*T)->lchild));
			//printf("right ");
			CreateBiTree(&((*T)->rchild));
			(*T)->flag = 0;
		}
	}
}
int PrintElement(ElemType c)
{
	printf("%c ", c);
	return 1;
}
//递归算法
int PreOrderTraverse0(BiTree T)
{
	if (T)
	{
		//printf("!");
		//先序遍历根结点
		if (PrintElement(T->data))//先打印出结点的数据元素
			//先序遍历左子树
			if (PreOrderTraverse0(T->lchild))//向左遍历该根结点下的左子树，若T->lchild为空，返回1且继续遍历右子树
				//先序遍历右子树
				if (PreOrderTraverse0(T->rchild))//遍历右子树，若T->rchild也为空，仍返回1，执行if语句的的分支“return 1”
					return 1;//表示以T为根节点的子树已经遍历完毕，返回父结点，继续向父节点的另一棵子树遍历
		return 0;
	}
	else
	{
		//printf("?");
		return 1;
	}
	//说明T这个子树为空，返回1进入另一棵子树遍历
}
void InOrderTraverse0(BiTree T)
{
	if (T != NULL)
	{
		InOrderTraverse0(T->lchild);
		PrintElement(T->data);
		InOrderTraverse0(T->rchild);
	}
}
void PostOrderTraverse0(BiTree T)
{
	if (T != NULL)
	{
		PostOrderTraverse0(T->lchild);
		PostOrderTraverse0(T->rchild);
		PrintElement(T->data);
	}
}
//非递归算法
void initzero(BiTree T)
{
	BiTree S[MAX_TREE_SIZE];
	BiTree p, q;
	p = T;
	int top = 0;
	if (T == NULL)
	{
		printf("二叉树为空。\n");
		return;
	}
	while (p != NULL)
	{
		p->flag = 0;
		//PrintElement(p->data);
		q = p->rchild;
		if (q != NULL)
		{
			top++;
			S[top] = q;
		}
		p = p->lchild;
		if (p == NULL && top > 0)
		{
			p = S[top];
			top--;
		}
	}
}
void PreOrderTraverse1(BiTree T)
{
	BiTree S[MAX_TREE_SIZE];
	BiTree p, q;
	p = T;
	int top = 0;
	if (T == NULL)
	{
		printf("二叉树为空。\n");
		return;
	}
	while (p != NULL)
	{
		PrintElement(p->data);
		q = p->rchild;
		if (q != NULL)
		{
			top++;
			S[top] = q;
		}
		p = p->lchild;
		if (p == NULL && top > 0)
		{
			p = S[top];
			top--;
		}
	}
}
void InOrderTraverse1(BiTree T)
{
	BiTree S[MAX_TREE_SIZE];
	BiTree p = T;
	int top = 0;
	if (T == NULL)
	{
		printf("二叉树为空。\n");
		return;
	}
	while (p != NULL || top > 0)
	{
		if (p != NULL)
		{
			S[top] = p;
			top++;
			p = p->lchild;
		}
		else
		{
			top--;
			p = S[top];
			PrintElement(p->data);
			p = p->rchild;
		}
	}
}
void PostOrderTraverse1(BiTree T)
{
	initzero(T);
	BiTree S[MAX_TREE_SIZE];
	BiTree p = T;
	int top = 0;
	if (T == NULL)
	{
		printf("二叉树为空。\n");
		return;
	}
	while (1)
	{
		if (p != NULL)
		{
			S[top] = p;
			top++;
			p = p->lchild;
		}
		else
		{
			top--;
			p = S[top];
			if (p->rchild == NULL || p->flag == 1)
			{
				PrintElement(p->data);
				p = NULL;
			}
			else
			{
				S[top] = p;
				top++;
				p->flag = 1;
				p = p->rchild;
			}
		}
		if (top == 0)
		{
			break;
		}
	}
}
void LeafNum(BiTree T)
{
	initzero(T);
	BiTree S[MAX_TREE_SIZE];
	BiTree p;
	p = T;
	int num = 0;
	int top = 0;
	if (T == NULL)
	{
		printf("二叉树为空。\n");
		return;
	}
	while (1)
	{
		if (p != NULL)
		{
			S[top] = p;
			top++;
			p = p->lchild;
		}
		else
		{
			top--;
			p = S[top];
			if (p->rchild == NULL || p->flag == 1)
			{
				if (p->rchild == NULL)
					num++;
				//PrintElement(p->data);
				p = NULL;
			}
			else
			{
				S[top] = p;
				top++;
				p->flag = 1;
				p = p->rchild;
			}
		}
		if (top == 0)
		{
			break;
		}
	}
	printf("叶子结点的个数为%d\n", num);
	return;
}
void Function7(BiTree T,int k)
{
	initzero(T);
	BiTree S[MAX_TREE_SIZE];
	BiTree p = T;
	int top = 0;
	//ElemType m[MAX_TREE_SIZE];
	int i = 0;
	if (T == NULL)
	{
		printf("二叉树为空。\n");
		return;
	}
	while (1)
	{
		if (p != NULL)
		{
			S[top] = p;
			top++;
			p = p->lchild;
		}
		else
		{
			top--;
			p = S[top];
			if (p->rchild == NULL || p->flag == 1)
			{
				//PrintElement(p->data);
				//m[i] = p->data;
				i++;
				if (k == i)
				{
					printf("第k个结点的值：%c\n", p->data);
					return;
				}
				p = NULL;
			}
			else
			{
				S[top] = p;
				top++;
				p->flag = 1;
				p = p->rchild;
			}
		}
		if (top == 0)
		{
			break;
		}
	}
}
void delsubtree(BiTree T) 
{
	if (T) 
	{
		delsubtree(T->lchild);  delsubtree(T->rchild);
		free(T);
	}//if
}//delsubtree
void DelTree(BiTree* T, ElemType x) 
{
	if (*T) 
	{
		if ((*T)->data == x) 
		{ 
			delsubtree(*T); 
			*T = NULL; 
		}
		else 
		{ 
			DelTree(&(*T)->lchild, x);
			DelTree(&(*T)->rchild, x); 
		}
	}//if
}//DelTree
void Function8(BiTree* T,ElemType x)
{
	BiTree S[MAX_TREE_SIZE];
	BiTree p, q;
	p = *T;
	int top = 0;
	if (p == NULL)
	{
		printf("二叉树为空。\n");
		return;
	}
	while (p != NULL)
	{
		//PrintElement(p->data);
		if ((p->rchild)->data == x)
		{
			p->rchild = NULL;
			free(p->rchild);
			q = NULL;
		}
		else
		{
			q = p->rchild;
		}
		if (q != NULL)
		{
			top++;
			S[top] = q;
		}
		if ((p->lchild)->data == x)
		{
			free(p->lchild);
			p->lchild = NULL;
		}
		else
		{
			p = p->lchild;
		}
		if (p == NULL && top > 0)
		{
			p = S[top];
			top--;
		}
	}
}
#define MAXSIZE 100
typedef struct
{
	BiTree data[MAXSIZE];
	int front;
	int rear;
}SqQueue;
void InitQueue(SqQueue* Q)
{
	Q->front = 0;
	Q->rear = 0;
}
int QueueEmpty(SqQueue* Q)//队列为空，返回1，否则返回0
{
	if (Q->front == Q->rear)
		return 1;
	else
		return 0;
}
void EnQueue(SqQueue* Q, BiTree e)
{
	if ((Q->rear + 1) % MAXSIZE == Q->front)
		return;//printf("队满\n");
	else
	{
		Q->data[Q->rear] = e;
		Q->rear = (Q->rear + 1) % MAXSIZE;
		//printf("插入完成\n");
	}
}
void DeQueue(SqQueue* Q, BiTree* e)
{
	if (QueueEmpty(Q))
		return;//printf("队空\n");
	else
	{
		*e = Q->data[Q->front];
		Q->front = (Q->front + 1) % MAXSIZE;
		//printf("删除完成\n");
	}
}
void Function10(BiTree T)
{
	BiTree p;
	p = T;
	SqQueue Q;
	InitQueue(&Q);
	if (p)
	{
		EnQueue(&Q, p);
	}
	while (!QueueEmpty(&Q))
	{
		DeQueue(&Q, &p);
		PrintElement(p->data);
		if (p->lchild)
			EnQueue(&Q, p->lchild);
		if (p->rchild)
			EnQueue(&Q, p->rchild);
	}
}
int main()
{
	BiTree T = NULL;
	printf("-----------------------------/功能/-------------------------\n");
	printf("   1.二叉树的二叉链表的创建\n");
	printf("   2.二叉树的前中后序遍历的递归算法\n");
	printf("   3.求二叉树中叶子结点数目的递归算法\n");
	printf("   4.求二叉树中位于后序序列第k个结点的值\n");
	printf("   5.删除二叉树中所有以值为x的结点为根的子树并释放相应空间\n");
	printf("   6.二叉树的前/中/后序遍历的非递归算法的实现\n");
	printf("   7.编写二叉树层序遍历的算法\n");
	printf("   0.退出\n");
	printf("请输入需要运行的功能（1-7）：");
	int n = 0;
	scanf("%d", &n);
	int t = 0;
	while (n)
	{
		switch (n)
		{
		case 1:
			CreateBiTree(&T);
			break;
		case 2:
		{
			getchar();
			printf("请输入遍历顺序(a.前序遍历/b.中序遍历/c.后序遍历)：");
			char c;
			scanf("%c", &c);
			if (c == 'a')
			{
				t = PreOrderTraverse0(T);
			}
			else if (c == 'b')
			{
				InOrderTraverse0(T);
			}
			else if (c == 'c')
			{
				PostOrderTraverse0(T);
			}
			printf("\n");
			break;
		}
		case 3:
			LeafNum(T);
			break;
		case 4:
		{
			int k = 0;
			getchar();
			printf("请输入结点的序号：");
			scanf("%d", &k);
			Function7(T, k);
			break;
		}
		case 5:
		{
			ElemType x;
			getchar();
			printf("请输入结点的值：");
			scanf("%c", &x);
			DelTree(&T, x);
			break;
		}
		case 6:
		{
			getchar();
			printf("请输入遍历顺序(a.前序遍历/b.中序遍历/c.后序遍历)：");
			char c;
			scanf("%c", &c);
			if (c == 'a')
			{
				PreOrderTraverse1(T);
			}
			else if (c == 'b')
			{
				InOrderTraverse1(T);
			}
			else if (c == 'c')
			{
				PostOrderTraverse1(T);
			}
			printf("\n");
			break;
		}
		case 7:
		{
			Function10(T);
			printf("\n");
			break;
		}
		default:
			break;
		}
		printf("请继续输入需要运行的功能（1-7）：");
		scanf("%d", &n);
	}
	return 0;
}

三、总结

仅作为个人实验作业内容，如有错误请各位指正。

LFY_LZL
关注
数据结构：二叉树的应用
04-25
一、 实验目的： 1、 掌握二叉树的定义和存储表示，掌握二叉树建立的算法； 2、 掌握二叉树的遍历（先序、中序、后序）算法 二、 问题描述 1. 查找自己家族的族谱，至少上溯至祖爷爷辈； 2. 族谱二叉树的建立（树的深度要>=4）； 3. 按照二叉树的结构输出二叉树； 4. 三种不同遍历算法遍历此二叉树； 5. 查找某人在二叉树中的位置，要求输出从根结点至查找结点的路径； 6. 统计二叉树的深度，输出叶子结点的信息。
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
二叉树的应用详解 - 数据结构
weixin_30883777的博客
06-25 793
概述： 平衡树——特点：所有结点左右子树深度差≤1 排序树——特点：所有结点“左小右大 字典树——由字符串构成的二叉排序树 判定树——特点：分支查找树（例如12个球如何只称3次便分出轻重） 带权树——特点：路径带权值（例如长度） 最优树——是带权路径长度最短的树，又称 Huffman树，用途之一是通信中的压缩编码。 1. 二叉排序树（二叉查找树Bin...
6.2哈夫曼树编码与解码
m0_65022800的博客
05-29 630
哈夫曼树相关的几个名词 路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图 1 中，从根结点到结点 a 之间的通路就是一条路径。 路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。 结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图 1 中结点 a 的权为 7，结点 b 的权为 5。 结点的带权路径长度：指的是从根结点到
【数据结构】--二叉树的应用
最新发布
m0_73866527的博客
02-01 227
二叉树
数据结构——二叉树(c).doc
09-25
【二叉树】是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树常用于计算机科学中的算法设计，比如搜索、排序以及表达式求解等场景。 在二叉树中...
数据结构——基于C语言实现二叉树的应用.cpp
08-11
/创建二叉树 //初始化二叉树 //创建队列 //出队 //队列判空 //入队 //先序递归遍历 //后序递归遍历 //中序递归遍历 //层次遍历
数据结构的实例教学——二叉树在信息加密中的应用.pdf
08-07
实践表明，这种结合二叉树应用的加密解密教学方法，能够提高学生学习数据结构的兴趣，同时也锻炼了他们的实际应用能力。 在当今信息化社会，信息安全的重要性不言而喻。数据结构的教学不仅是为了培养学生掌握基础...
数据结构——二叉树有关操作程序
12-17
(1)以二叉链表作为存储结构，从键盘以先序次序输入各个结点（空格字符表示空树）建立一棵二叉树； (2)对（1）中生成的二叉树进行判空； (3)对（1）中生成的二叉树进行遍历（分别实现先序遍历、中序遍历、后序...
数据结构二叉树的应用实例
02-25
c++ 数据结构 二叉树的应用实例 详细的介绍了二叉树的应用
数据结构入门----二叉树的应用
qq1457346557的博客
07-04 2714
一. 实验要求 实现二叉树创建算法，在此基础上实现二叉树的先序、后序递归遍历算法、两种非递归中序遍历、层序遍历、求二叉树的深度。注意：在非递归算法中用到栈和队列时，不要调用系统的栈和队列，需要自己实现栈和队列的操作。 二. 实验目的 通过该实验，理解二叉树的链式存储，掌握二叉树的几种遍历算法，并理解递归的含义，掌握C语言编写递归函数的方法和注意事项。 三. 设计思想 1.首先进行先序创建二叉树。从键盘输入字符c，如果c是‘$’则说明该结点是空；否则，为该结点申请一个空间，让数据data等于c，接着利
数据结构-二叉树的应用学习
天使之翼
08-13 603
二叉树的应用 本节介绍二叉树的基本应用，包括求二叉树的叶结点数、总结点数、二叉树的深度等，重点介绍标识符树的应用。 二叉树的基本应用 1．统计二叉树叶子结点数 （1）基本思想。若二叉树结点的左子树和右子树都为空，则该结点为叶子结点。可先对全局变量count+1，然后依次递归统计T的左子树叶子结点数和T的右子树叶子结点数。 （2）具体算法如下。 void Leafnum(BT *T) //求二叉树的...
数据结构之二叉树的应用——二叉平衡查找树
huxxyyy的博客
09-09 558
二叉查找树和二叉平衡查找树 一.二叉查找树 1.数据类型定义： typedef int InfoType;typedef int KeyType; // 假定关键字类型为整数 typedef struct node // 结点类型 { KeyType key; // 关键字项 InfoType otherinfo; // 其它数据域，InfoType视应用情况而定 下面 // 不处理它 struct node *lchild,*rchild
数据结构-二叉树及其应用
m0_62464074的博客
12-15 1709
实验项目名称 二叉树及其应用 实验要求 树是数据结构中应用极为广泛的非线性结构，本单元的实验达到熟悉二叉树的存储结构的特性，以及如何应用树结构解决具体问题。 实验内容 利用二叉树求解表达式的值。 算法分析 void EXTInitStack(ETLinkStack& LS)// 树栈初始化 { LS = NULL; } void EXTPush(ETLinkStack& LS, ExpTree ET)// 树栈添加元素 { ETStackNode...
数据结构实验7---二叉树的应用
qq_62474991的博客
12-13 580
重点： 二叉树的遍历 难点： 中序遍历的非递归实现，层序遍历的实现
数据结构 二叉树的应用算法
ZSS1753936255的博客
12-19 482
/*这里我们只要讲一下，就是建立二叉树了。有二种建立二叉树的 方法。我们讲一下。*/ #include #include #define MAX 20 typedef struct BiTNode { char date; struct BiTNode* lchild,*rchild; }*BiTree; void CreateBiTree_1(BiTree*);/
数据结构--树与二叉树的应用
知足且上进，温柔而坚定
09-10 1461
1. 二叉排序树(BST) Binary Search Tree 二叉排序树的插入 int BST_Insert(BSTree& T, ElemType k) { if (!T) { //原树为空 新插入的结点为根结点 T = (BSNode*)malloc(sizeof(BSNode)); if (!T) { //申请失败 return 0; } T->key = k;
数据结构_二叉树及其应用_C实例实现
xuchaoxin1375的博客
08-11 2131
/*二叉树及其应用 * 树是由n（n≥0）个结点构成的一个有限集合以及在该集合上定义的一种结点关系，集合中的元素称为树的结点。 n=0的树称为树|当n子0时，树中的结点应该满足以下两个。 把由子集T、T2……T。构成的树称作根的子树（Subtree）。 条件： （1）必有一个特定的称为根（root）的结点，这个根结点没有前驱。 94树和二叉树 （2）剩下的结点可以被分成n个（n≥0）互不相交的子集T1、T2、……T。，而且，每一个子集又都是树. 许多实际应用中，对象呈现出一种非线性的次序，其主要表现在结
清华大学版数据结构——深入解析树与二叉树
"数据结构（清华大学版）——树和二叉树" 在计算机科学中，树是一种非线性数据结构，广泛应用于各种算法和数据存储。清华大学版的数据结构教材详细阐述了树和二叉树的相关概念，这对于理解和掌握数据结构至关重要。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值