二叉树及其应用

最新推荐文章于 2024-07-21 13:46:57 发布
最新推荐文章于 2024-07-21 13:46:57 发布
阅读量518 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smalldregs/article/details/103657726
版权

设计并验证如下算法：按中序建立两棵二叉树的二叉链表结构，判断两棵二叉树是否相等。

#include"stdio.h"
#include"stdlib.h"
#include"string.h"
#define OK		1
#define ERROR	0
#define LIST_INIT_SIZE 50
#define LISTINCREMENT  50
typedef int Status;
typedef char TElemType;
typedef struct BiTNode 
{
	TElemType data;
	struct BiTNode *lchild, *rchild;
	int position;
}BiTNode, *BiTree;
typedef char SElemType;
#include"StackForBiTNode.h"		//储存结点指针的栈 
Stack S;
struct Data
{
	char data;
	bool IsData;
};
typedef struct Data ElemType; 
struct LIST
{
	ElemType *elem;
	int length;
	int listsize;
};
typedef struct LIST SqList;
Status InitList_SqList(SqList *L) 
{
	L->elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
	L->length = 0;
	L->listsize = LIST_INIT_SIZE;
	return OK;
}
void InputList_SqList(SqList *L) 
{
	ElemType e;
	ElemType *newbase, *p;
	char a;
	while(1) 
	{
		scanf("%c", &a);
		if(a == '\n')
			break;
		e.data = a;
		e.IsData = false;
		if(a != '(' && a != ')' && a != '#')
			e.IsData = true;
		if(L->length >= L->listsize)
		{
			newbase = (ElemType *)realloc(L->elem, (L->listsize+LISTINCREMENT)*sizeof(ElemType));
			L->elem = newbase;
			L->listsize += LISTINCREMENT;
		}
		
		p=&L->elem[L->length];
		*p = e;
		L->length++;
	}
}
void printlist_SqList(SqList L) 
{
	printf("data:\t");
	for(int i=0; i<L.length; i++)
	printf("%c  ",L.elem[i].data);
	printf("\n");
}
Status InitBiTree(BiTree *);
BiTree CreateBiTree(BiTree *);	
Status PreOrder(BiTree );
bool Equal(BiTree , BiTree );
bool ExitLeft(SqList , int); 	 
bool ExitRight(SqList , int);
int LeftData(SqList , int );	
int RightData(SqList , int );
Status BiTreeInsLeft(BiTree *, char );		 
Status BiTreeInsRight(BiTree *, char );		 
int main() 
{	
	BiTree BT1, BT2;
	InitStack(&S);
	printf("\n创建第一棵树1\n以先序输入 :");
	InitBiTree(&BT1);
	BT1 = CreateBiTree(&BT1);
	printf("创建成功!\n");
	printf("\n创建第二棵树2\n以先序输入 :");
	InitBiTree(&BT2);
	BT2 = CreateBiTree(&BT2);
	printf("创建成功!\n");
	printf("先序输出树1\n");
	PreOrder(BT1);
	printf("先序输出树2\n");
	PreOrder(BT2);
	printf("判断是否相等\n");
	if(Equal(BT1, BT2))
		printf("\n两树相等!\n");
	else
		printf("\n 两树不相等!\n");
	return 0;
}
 
Status InitBiTree(BiTree *BT) 
{
	*BT = NULL;
	return 0;
}
 
BiTree CreateBiTree(BiTree *BT) 
{
	TElemType ch;
	SqList L;
	InitList_SqList(&L);
	InputList_SqList(&L);
	printlist_SqList(L);
	BiTNode *node, *root;
	int index = 0, count = 0;	
	for(int i = 1; i < L.length; i++) 
	{	 
		if(L.elem[i].data == '(')
			count ++;
		if(L.elem[i].data == ')')
			count --;
		if(count == 0)
		{
			index = i+1;break;
		}
	}
	while(L.elem[index].IsData == false) //如果该位置不是data，则往后一个位置	
		index++;
	*BT = (BiTNode *)malloc(sizeof(BiTNode));
	(*BT)->data = L.elem[index].data;
	(*BT)->position = index;
	(*BT)->lchild = NULL;
	(*BT)->rchild = NULL;
	push(&S, *BT);
	root = *BT;		
	while(!emptyStack(&S)) 
	{
		node = getTop(&S);
		index = node->position;
		if(ExitLeft(L, index) && node->lchild == NULL) 
		{
			index = LeftData(L, index-2);	//找到左子树结点并插入
			ch = L.elem[index].data;
			BiTreeInsLeft(&(*BT),ch);
			node->lchild->position = index;
			push(&S,node->lchild); 
		}
		
		else if(ExitRight(L, index) && node->rchild == NULL) 
		{
			node = pop(&S);
			index = RightData(L, index+2);//找到右子树结点并插入 
			ch = L.elem[index].data;
			*BT = node;
			BiTreeInsRight(&(*BT), ch);
			
			node->rchild->position = index;
			push(&S,node->rchild);
		}
		else {
			node = pop(&S);
			index = node->position;
		}	
	}
	return root;
}
bool ExitLeft(SqList L, int index) 
{
	while(index >= 0) {
		index--;
		if(L.elem[index].data == ')')
			return true;
		if(L.elem[index].data == '(')
			return false;	
	}
	return false;
}
 

bool ExitRight(SqList L, int index)  
{
	while(index < L.length) {
		index++; 
		if(L.elem[index].data == '(')
			return true;
		if(L.elem[index].data == ')')
			return false;	
	}
	return false;
}
int LeftData(SqList L, int index)//找左子树结点，返回在顺序表的位置
 {
	int ind, count = 0;
	for(int i = index; i >= 0; i--)//从index位置开始，当左右括号抵消时，找到左子树结点 
	{ 
		if(L.elem[i].data == ')')
			count ++;
		if(L.elem[i].data == '(')
			count --;
		if(count == 0) {
			ind = i-1; break;
		}
	}
	while(L.elem[ind].IsData == false)	//如果该位置不是data，则往后一个位置
		ind++;
	return ind;
}
int RightData(SqList L, int index) //找右子树结点，返回在顺序表的位置
{
	int ind, count = 0;
	for(int i = index; i < L.length; i++) //从index位置开始，当左右括号抵消时，找到右子树结点
	{	
		if(L.elem[i].data == '(')
			count ++;
		if(L.elem[i].data == ')')
			count --;
		if(count == 0) {
			ind = i+1; break;
		}
	}
	while(L.elem[ind].IsData == false)	//如果该位置不是data，则往前一个位置
		ind--;
	return ind;
}
Status BiTreeInsLeft(BiTree *BT, char data) 
{
	BiTNode *new_node;
	new_node = (BiTNode *)malloc(sizeof(BiTNode));
	if(BT == NULL)
		return -1;
	else {
		if((*BT)->lchild != NULL)
			return -1;
		else
			(*BT)->lchild = new_node;
	}
	new_node->data = data;
	new_node->lchild = NULL;
	new_node->rchild = NULL;
	*BT = new_node;
	return 0;
}
Status BiTreeInsRight(BiTree *BT, char data) 
{
	BiTNode *new_node;
	new_node = (BiTNode *)malloc(sizeof(BiTNode));
	if(BT == NULL)
		return -1;
	else {
		if((*BT)->rchild != NULL)
			return -1;
		else
			(*BT)->rchild = new_node;
	}
	new_node->data = data;
	new_node->lchild = NULL;
	new_node->rchild = NULL;
	*BT = new_node;
	return 0;
}
Status PreOrder(BiTree BT) {
	if(BT) {
		//(!(BT->data))
		//eturn ERROR;
		printf("%c ", BT->data);
		PreOrder(BT->lchild);
		PreOrder(BT->rchild);
		return OK; 
	}
	return 0;
}
bool Equal(BiTree BT1, BiTree BT2) {
	if((!BT1) && (!BT2))	
		return true;
	if(BT1->data == BT2->data)
		if(Equal(BT1->lchild, BT2->lchild) && (Equal(BT1->rchild, BT2->rchild)))
			return true;
	return false;
}

设计并验证如下算法：输入一棵二叉树的广义表形式，建立该二叉树的二叉链表结构，并求其总结点数目。例如，对“12.7.4 参考源程序”所示二叉树，按下列形式读入字符：C(E(I,J),F(,G(K,H))#。

#include"stdio.h"
#include"string.h"
#include"stdlib.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
#define Max_Tree_SIZE 20
#define STACK_INIT_SIZE 100
#define STACKINCRENT 10
#define MAXQSIZE 100
typedef int Status;
typedef char TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiNode,*BiTree;
typedef BiTree SElemType;
typedef struct Inode
{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack *S)
{
	S->base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(!S->base)
		exit(OVERFLOW);
	S->top=S->base;
	S->stacksize=STACK_INIT_SIZE;
	return OK;
}
Status GetTop(SqStack S,SElemType *e)
{
	if(S.top==S.base)
		return ERROR;
	*e=*(S.top-1);
	return OK;
}
Status Push(SqStack *S,SElemType *e)
{
	if(S->top-S->base>=S->stacksize)
	{
		S->base=(SElemType*)realloc(S->base,(S->stacksize+STACKINCRENT)*sizeof(SElemType));
		if(!S->base)
			exit(OVERFLOW);
		S->top=S->base+S->stacksize;
		S->stacksize+=STACKINCRENT;
	}
	*S->top++=*e;
	return OK;
}
Status Pop(SqStack *S,SElemType *e)
{
	if(S->top==S->base)
		return ERROR;
	*e=*S->top;
	return OK;
}
Status InitBiTree(BiTree *BT);
Status CreateBiTree(BiTree *BT);
Status PreOrder(BiTree BT);
Status InOrder(BiTree BT);
Status PostOrder(BiTree BT);
int NodeNumber(BiTree BT);
void main()
{
	BiTree BT;
	int flag=1,select;
	CreateBiTree(&BT);
	while(flag)
	{
		printf("请选择\n");
		printf("1.先序\n");
		printf("2.中序\n");
		printf("3.后序\n");
		printf("4.求结点数\n");
		printf("5.退出\n");
		scanf("%d",&select);
		switch(select)
		{
		case 1:PreOrder(BT);break;
		case 2:InOrder(BT);break;
		case 3:PostOrder(BT);break;
		case 4:printf("%d",NodeNumber(BT));break;
		default:flag=0;
			printf("no");
			break;
		}
		printf("\n");
	}
}
Status InitBiTree(BiTree *BT)
{
	*BT=NULL;
	return OK;
}
Status CreateBiTree(BiTree *BT)
{
	SqStack S;
	InitStack(&S);
	*BT=NULL;
	char ch;
	int flag;
	SElemType p,e;
	scanf("%c",&ch);
	while(ch!='#')
	{
		switch(ch)
		{
		case'(':Push(&S,&p);flag=1;break;
		case',':flag=0;break;
		case')':Pop(&S,&p);break;
		default:p=(BiNode*)malloc(sizeof(BiNode));
			p->lchild=p->rchild=NULL;
			p->data=ch;
			if(!(*BT))
				*BT=p;
			else
			{
				GetTop(S,&e);
				if(flag)
					e->lchild=p;
				else
					e->rchild=p;
			}
			break;
		}
		scanf("%c",&ch);
	}
	return OK;
}
Status PreOrder(BiTree BT)
{
	if(BT)
	{
		if(!(BT->data))
			return ERROR;
		printf("%c",BT->data);
		PreOrder(BT->lchild);
		PreOrder(BT->rchild);
		return OK;
	}return OK;
}
Status InOrder(BiTree BT)
{
	if(BT)
	{
		if(!(BT->data))
			return ERROR;
		InOrder(BT->lchild);
		printf("%c",BT->data);
		InOrder(BT->rchild);
		return OK;
	}return OK;
}
Status PostOrder(BiTree BT)
{
	if(BT)
	{
		if(!(BT->data))
			return ERROR;
		PostOrder(BT->lchild);
		PostOrder(BT->rchild);
		printf("%c",BT->data);
		return OK;
	}return OK;
}

int NodeNumber(BiTree BT)
{
	if(!BT)
		return 0;
	else
		return NodeNumber(BT->lchild)+NodeNumber(BT->rchild)+1;

}
smalldregs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广义表形式建立二叉树，并按层次遍历该二叉树
05-18
二叉树采用二叉链表结构表示。设计并实现如下算法：输入某棵二叉树的广义表形式，建立该二叉树，并按层次遍历该二叉树
数据结构——c语言 中序二叉树判断相等
起当风萧的博客
04-12 2099
设计并验证如下算法:按中序序列建立两棵二叉树的二叉链表结构，判断两棵二叉树是否相等。 直接上代码： #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<string.h> #define OK 1 #define ERROR 0 typedef int Status; typedef char TElemType; typedef struct BiTNode {..
二叉树 （基本概念和应用场景）+ 常见算法题
最新发布
qq_20770569的博客
07-21 759
二叉树（Binary Tree）是计算机科学中的一种重要数据结构。二叉树是一个有限节点的集合，这个集合或者为空（称为空二叉树），或者由一个根节点以及两棵互不相交的、分别称作左子树和右子树的二叉树组成。
设计并验证如下算法：输入一棵二叉树的广义表形式，建立该二叉树的二叉链表结构，分别实现层次遍历、非递归中序遍历该二叉树。
qq_51935763的博客
06-06 768
#include<stdio.h> #include<stdlib.h> typedef struct b_tree { char data;//这里可以自由修改 如果是字母那就char struct b_tree *left,*right; }Tree,*B_tree;//结点 void floor_traverse(B_tree tree) { B_tree queue[100];//数组当队列 int head=0,rear=0;//头指针和尾指针 queue[head++]=
二叉树及其作用浅析
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
10-14 1万+
在学习数据结构和算法时看到各种树，把人都整蒙了，枯燥且提不起学习兴趣。等逐渐感受到二叉树的神奇作用和巨大的应用价值后，觉得二叉树原来也这么有趣，值得好好学习。 先从整体上认识下二叉树及其他各种树的区别和用途。 大致有哪些树？ 树有很多种，其中二拆树因为其特殊的结构和特点在计算上最为常用。 常见的二叉树：二叉查找树，平衡二叉树(AVL)，红黑树，B+树，B-树，字典树，满二叉树，完全二叉树，霍夫曼树，伸展树，最小堆，最大堆等。 二叉树有什么用？ 二叉树应用非常广泛。 在操作系统源程序中，树和.
数据结构学习--二叉树及其应用
06-25
总的来说，这个程序涵盖了二叉树的基本操作，包括构造、遍历和释放，是学习二叉树及其应用的一个典型实例。通过这个程序，我们可以深入理解二叉树的链式存储结构和遍历算法，这对于后续学习其他复杂的数据结构和算法...
二叉树及其应用.docx
01-26
二叉树及其应用 本文档详细介绍了二叉树的定义、性质、存储方式、建立、遍历及其算法的实现，并深入了解哈夫曼树的建立、哈夫曼编码和译码。通过实验，掌握了二叉树的遍历顺序、哈夫曼树的建立和哈夫曼编码的实现。...
6_二叉树及其应用.ppt
07-19
二叉树的用法以及它的应用。 事宜人群：学习c++的，且与c++接触过的人群
实验5 二叉树及其应用(1).rar
05-17
在本实验“实验5 二叉树及其应用”中，你将有机会实践这些概念，通过编程实现二叉树的创建、遍历、插入和删除操作，并了解它们在实际问题中的应用。这将帮助你深入理解二叉树的理论知识，并提升你的编程技能。通过...
二叉树的应用详解 - 数据结构
热门推荐
黄规速博客:学如逆水行舟，不进则退
06-25 4万+
概述： 平衡树——特点：所有结点左右子树深度差≤1 排序树——特点：所有结点“左小右大 字典树——由字符串构成的二叉排序树 判定树——特点：分支查找树（例如12个球如何只称3次便分出轻重） 带权树——特点：路径带权值（例如长度） 最优树——是带权路径长度最短的树，又称 Huffman树，用途之一是通信中的压缩编码。 1. 二叉排序树（二叉查找树Binary Sear
二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现...
weixin_30588907的博客
09-28 329
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。 完全二叉树：除了最大的层次即成为一颗满二叉树且层次最大那层所有的结...
数据结构——二叉树的原理与代码应用
流楚丶格念的博客
10-30 4593
本文下月再整理 这月凑够40篇
二叉树的实际应用（应用场景）
心向暖的博客
03-20 3万+
哈夫曼编码，来源于哈夫曼树（给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为赫夫曼树(Huffman tree)。即带权路径长度最短的树），在数据压缩上有重要应用，提高了传输的有效性，详见《信息论与编码》。 海量数据并发查询，二叉树复杂度是O(K+LgN)。二叉排序树就既有链表的好处，也有数组的好处，在处理大批量的动态的数据是比较有用。 ...
【全面解析！】二叉树及其应用
m0_64799333的博客
03-06 2120
1.在用树表示的目录结构中，从根目录到任何数据文件只有唯一一条通道，因为树的特点是不相交2.3.（1）根据中序遍历和后序遍历顺序构建二叉树（2）根据前序遍历和中序遍历顺序构建二叉树Q1：为什么后序+中序构建二叉树是先root.left再root.right;而前序+中序构建二叉树是先root.right再root.left?A1:根据上面的图片我们可以看到，根据后序遍历的顺序，我们先在中序中找到根节点，下一步找到的是右树，所以我们在写代码的时候要先写root，再right，最后left；
二叉树的应用
zd454909951的博客
12-19 1124
一、二叉排序树在建立二叉树的同时，数据已经经过初步的比较，并按照二叉树的建立规则来存放数据，规则如下： 第一个输入数据作为根节点 之后的数据以递归的方式与树根进行比较，小于树根置于左子树，大于树根置于右子树 按照上述规则建立好二叉树后，只要利用中序遍历方式就可得到由小到大排序好的数据。如果想得到由大到小排列，可将最后结果置于堆栈内再POP出来。二、二叉搜索树如果一个二叉树符合“每一个节点的数据大于左
二叉树的基础应用
qq_52642334的博客
02-02 698
二叉树
数据结构之二叉树及其应用
m0_72936412的博客
06-12 802
数据结构之二叉树及其应用
二叉树及其应用的常见错误
05-19
以下是二叉树及其应用中常见的错误： 1. 忘记判断空指针。在对二叉树进行遍历、插入或删除操作时，经常会出现忘记判断空指针的情况，导致程序崩溃或者逻辑错误。 2. 没有考虑到平衡问题。在使用二叉搜索树进行查找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值