数据结构——二叉树的基本操作（二）

最新推荐文章于 2023-12-03 16:38:35 发布
最新推荐文章于 2023-12-03 16:38:35 发布
阅读量2.5k 收藏 23
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxl_d/article/details/102808092
版权

一、实验目的及要求

1.理解二叉树的基本概念和特点
2.掌握二叉树的链式存储结构
3.掌握二叉树的基本操作
4.掌握二叉树遍历操作

二、实验内容（或实验原理、实验拓扑）

1.实现二叉树的如下操作，先序遍历、中序遍历和后序遍历的递归算法，二叉树如下图所示。(采用二叉链存储结构实现)
(1)采用括号表示法，构建如下二叉树，并输出二叉树b；
(2)采用递归算法，输出二叉树的先序序列；（参考课本212页代码）
(3)采用递归算法，输出二叉树的中序序列；
(4)采用递归算法，输出二叉树的后序序列；
2.实现上述二叉树的先序遍历的算法。

三、实验设计方案（包括实验步骤、设计思想、算法描述或开发流程等）

（一）先、中、后序遍历递归思路与写法：
  1. 先、中、后序遍历递归思路
先序遍历：先遍历根节点，再遍历左子树，再遍历右子树，所以最先输出根节点；
中序遍历：先遍历根节点左子树，再遍历根节点，再遍历右子树；
后序遍历：先遍历左子树，再右子树，最后根节点。
2.递归算法的基本操作函数以及主函数（详细代码见附录）：
(1)	创建二叉树CreateBTNode(*b,*str)：根据二叉树括号表示法字符串str生成对
应的二叉链存储结构，后者的根结点为*b。
(2) 输出二叉树DispBTNode(BTNode *b)：以括号表示法输出一棵二叉树。
(3) 销毁二叉树DestroyBTNode(BTNode *&b)：销毁二叉树b。
(4) 先序遍历递归算法PreOrder(BTNode * b)
(5) 中序遍历递归算法InOrder(BTNode * b)
(6) 后序遍历递归算法PostOrder(BTNode * b)
(7)主函数main（）：根据问题依次调用基本操作函数并编写通俗易懂的语句输出。
（二） 先序遍历非递归方法的基本思路与算法：
1. 先序遍历非递归方法的基本思路：
利用栈先输出当前节点（根），然后将所以其左节点压到栈中，方便后面出栈来处理其的右节点，然后把当前的对象指针指到其左节点（左），然后 while 判断指针不为空，所以继续将其输出，然后移到其左节点，直到没有左节点了，通过出栈开始处理右节点（右）。
2.非递归算法的基本操作函数以及主函数（详细代码见附录）：
(1)	创建二叉树CreateBTNode(*b,*str)：根据二叉树括号表示法字符串str生成对
应的二叉链存储结构，后者的根结点为*b。
(2) 输出二叉树DispBTNode(BTNode *b)：以括号表示法输出一棵二叉树。
(3) 销毁二叉树DestroyBTNode(BTNode *&b)：销毁二叉树b。
(4) 初始化栈InitStack(SqStack *&s) 
(5) 销毁栈DestroyStack(SqStack *&s) 
(6) 判断栈是否为空StackEmpty(SqStack *s)
(7) 进栈Push(SqStack *&s,BTNode *e) 
(8) 出栈Pop(SqStack *&s,BTNode *&e) 
(9) 取栈顶元素GetTop(SqStack *s,BTNode *&e) 
(10) 先序遍历非递归算法PreOrder2(BTNode *b) 
(11)主函数main（）：根据问题依次调用基本操作函数并编写通俗易懂的语句输出。

四、实验结果（包括设计效果、测试数据、运行结果等）

（一）递归算法的运行结果如下：

（二）非递归算法的运行结果如下：

五、实验小结（包括收获、心得体会、注意事项、存在问题及解决办法、建议等）

二叉树的遍历是指按照一定次序访问树中所有节点，并且每个节点仅被访问一次的过程。遍历操作实际上是将非线性结构线性化的过程，其结果为线性序列，并根据采用的遍历顺序分别称为先序序列、中序序列、后序序列。

六、附录（包括作品、流程图、源程序及命令清单等）

（一）递归算法：

#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
	ElemType data;				//数据元素
	struct node *lchild;		//指向左孩子
	struct node *rchild;		//指向右孩子
} BTNode;
void CreateBTNode(BTNode *&b,char *str)		//由str串创建二叉链
{
	BTNode *St[MaxSize],*p=NULL;
	int top=-1,k,j=0;  
	char ch;
	b=NULL;				//建立的二叉树初始时为空
	ch=str[j];
	while (ch!='\0')	//str未扫描完时循环
	{
   	   	switch(ch) 
		{
		case '(':top++;St[top]=p;k=1; break;		//为左节点
		case ')':top--;break;
		case ',':k=2; break;                      	//为右节点
		default:p=(BTNode *)malloc(sizeof(BTNode));
			p->data=ch;p->lchild=p->rchild=NULL;
		         	if (b==NULL)                    //p指向二叉树的根节点
						b=p;
					else  							//已建立二叉树根节点
					{	
						switch(k) 
						{
						case 1:St[top]->lchild=p;break;
						case 2:St[top]->rchild=p;break;
						}
					}
		}
		j++;
		ch=str[j];
	}
}
void DispBTNode(BTNode *b)	//以括号表示法输出二叉树
{
	if (b!=NULL)
	{
		printf("%c",b->data);
		if (b->lchild!=NULL || b->rchild!=NULL)
		{
			printf("(");
			DispBTNode(b->lchild);
			if (b->rchild!=NULL) printf(",");
			DispBTNode(b->rchild);
			printf(")");
		}
	}
}
void DestroyBTNode(BTNode *&b)  //销毁二叉树 
{
	if (b!=NULL)
	{
		DestroyBTNode(b->lchild);
		DestroyBTNode(b->rchild);
		free(b);
	}
}
void PreOrder(BTNode * b)  //先序遍历递归算法
{
	if(b!=NULL)
	{
		printf(" %c",b->data);   //访问根结点 
		PreOrder(b->lchild);     //先序遍历左子树 
		PreOrder(b->rchild);     //先序遍历右子树 
	}
} 
void InOrder(BTNode * b)   //中序遍历递归算法
{
	if(b!=NULL)
	{
		InOrder(b->lchild);     //中序遍历左子树 
		printf(" %c",b->data);   //访问根结点 
		InOrder(b->rchild);     //中序遍历右子树 
	}
} 
void PostOrder(BTNode * b)  //后序遍历递归算法
{
	if(b!=NULL)
	{
		PostOrder(b->lchild);     //后序遍历左子树 
		PostOrder(b->rchild);     //后序遍历右子树
		printf(" %c",b->data);   //访问根结点  
	}
} 
int main()
{
	BTNode *b;
	CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
	printf("二叉树b:  ");
	DispBTNode(b);
	printf("\n");
	printf("先序遍历序列:");
	printf("\n");
	printf("\t递归算法：");
	PreOrder(b);
	printf("\n");
	printf("中序遍历序列:"); 
	printf("\n");
	printf("\t递归算法：");
	InOrder(b);
	printf("\n");
	printf("后序遍历序列:");
	printf("\n");
	printf("\t递归算法：");
	PostOrder(b);
	printf("\n");
	return 0;
}

（二）非递归算法：

btree.cpp
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
	ElemType data;				//数据元素
	struct node *lchild;		//指向左孩子
	struct node *rchild;		//指向右孩子
} BTNode;
void CreateBTNode(BTNode *&b,char *str)		//由str串创建二叉链
{
	BTNode *St[MaxSize],*p=NULL;
	int top=-1,k,j=0;  
	char ch;
	b=NULL;				//建立的二叉树初始时为空
	ch=str[j];
	while (ch!='\0')	//str未扫描完时循环
	{
   	   	switch(ch) 
		{
		case '(':top++;St[top]=p;k=1; break;		//为左节点
		case ')':top--;break;
		case ',':k=2; break;                      	//为右节点
		default:p=(BTNode *)malloc(sizeof(BTNode));
			p->data=ch;p->lchild=p->rchild=NULL;
		         	if (b==NULL)                    //p指向二叉树的根节点
						b=p;
					else  							//已建立二叉树根节点
					{	
						switch(k) 
						{
						case 1:St[top]->lchild=p;break;
						case 2:St[top]->rchild=p;break;
						}
					}
		}
		j++;
		ch=str[j];
	}
}

void DispBTNode(BTNode *b)	//以括号表示法输出二叉树
{
	if (b!=NULL)
	{
		printf("%c",b->data);
		if (b->lchild!=NULL || b->rchild!=NULL)
		{
			printf("(");
			DispBTNode(b->lchild);
			if (b->rchild!=NULL) printf(",");
			DispBTNode(b->rchild);
			printf(")");
		}
	}
}


void DestroyBTNode(BTNode *&b)
{
	if (b!=NULL)
	{
		DestroyBTNode(b->lchild);
		DestroyBTNode(b->rchild);
		free(b);
	}
}

think1.cpp

#include "btree.cpp"
typedef struct
{	BTNode *data[MaxSize];			//存放栈中的数据元素
	int top;						//存放栈顶指针，即栈顶元素在data数组中的下标
} SqStack;							//顺序栈类型

void InitStack(SqStack *&s)			//初始化栈
{	s=(SqStack *)malloc(sizeof(SqStack));//分配一个是顺序栈空间，首地址存放在s中
	s->top=-1;						//栈顶指针置为-1
}
void DestroyStack(SqStack *&s)		//销毁栈
{
	free(s);
}
bool StackEmpty(SqStack *s)			//判断栈是否为空
{
	return(s->top==-1);
}
bool Push(SqStack *&s,BTNode *e)	//进栈
{	if (s->top==MaxSize-1)			//栈满的情况，即栈上溢出
		return false;
	s->top++;						//栈顶指针增1
	s->data[s->top]=e;				//元素e放在栈顶指针处
	return true;
}
bool Pop(SqStack *&s,BTNode *&e)	//出栈
{	if (s->top==-1)					//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];				//取栈顶指针元素的元素
	s->top--;						//栈顶指针减1
	return true;
}
bool GetTop(SqStack *s,BTNode *&e)	//取栈顶元素
{	if (s->top==-1)					//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];				//取栈顶元素
	return true;
}

void PreOrder2(BTNode *b)      //先序遍历非递归算法
{       BTNode *p;
        SqStack *st;		//定义一个顺序栈指针st
        InitStack(st);			//初始化栈st
         p=b;
         while (!StackEmpty(st) || p!=NULL)
          {
			 while (p!=NULL)	 //访问结点p及其所有左下结点并进栈
			 {
				 printf(" %c",p->data);
		         Push(st,p);
		         p=p->lchild;		//移动到左孩子
	     }
	      //以下考虑栈顶结点
	     if (!StackEmpty(st))		//若栈不空
	      {	Pop(st,p);
		    p=p->rchild;		//转向处理其右子树
	      }
        }
           printf("\n");
           DestroyStack(st);			//销毁栈
}

int main()
{
    BTNode *b;
	CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
	printf("二叉树b:");
	DispBTNode(b);
	printf("\n");
	printf("先序遍历序列:\n");
	printf("    非递归算法:");
	PreOrder2(b);printf("\n");
	DestroyBTNode(b);
	return 1;
}
yxl_d
关注
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
二叉树-数据结构
weixin_60613303的博客
11-18 977
二叉树数据结构简单操作
二叉树的遍历：数据结构实验之二叉树二：遍历二叉树
s_t_a_r_s的博客
02-17 663
例：通过下列例子了解二叉树的遍历。 Problem Description 已知二叉树的一个按先序遍历输入的字符序列，如abc,,de,g,,f,,,(其中,表示空结点)。请建立二叉树并按中序和后序的方式遍历该二叉树。 Input 连续输入多组数据，每组数据输入一个长度小于50个字符的字符串。 Output 每组输入数据对应输出2行： 第1行输出中序遍历序列； ...
二叉树的基本操作（C语言实现）
03-23
NULL 博文链接：https://touch-2011.iteye.com/blog/1058160
二叉树基础操作
weixin_63178060的博客
10-15 1248
层序遍历相对于前三种遍历，需要用队列进行辅助操作，具体操作：定义一个队列，首先将二叉树的第一个结点入队，while循环判断该队列是否为空，不为空的话，则先进行出队，然后判断该树的左又子树是否为空，不为空则入队。在销毁时，不能先销毁根结点，因为其左子树和右子树是通过根结点访问的，如果根结点先被销毁，则其左子树和右子树在后序程序中无法被访问，会出现错误。满二叉树：一个二叉树，如果其每一层的结点都达到最大值，即结点个数为2^k-1，k为二叉树层数，则该树为满二叉树。（n0为度为0的结点，n2为度为2的结点）
二叉树基本操作
青耕_的博客
02-17 1646
二叉树的先序，中序，后序遍历的递归与非递归，二叉排序树的建立，添加，删除，满二叉树，完全二叉树的判断
二叉树的基本操作
最新发布
2301_77838258的博客
12-03 449
BuyTreeNode用来创建新节点,BinaryTreeCreate用来创建整个树,并返回根节点,传入数组a和一个用来控制下标的pi,pi初始是0,如果K为1表示当前节点是第K层的节点,返回1,否则返回左子树和右子树的第K-1层的节点数。如果当前节点是要查找的,直接返回,不然就向左子树和右子树找,返回找到的节点,找不到返回空。从某个节点到其最远叶节点的路径上的节点数称为该节点的高度。从根节点到某个节点的唯一路径上的节点数称为该节点的深度。没有子节点的节点称为叶节点，它们位于二叉树的末端。
数据结构实验三——二叉树基本操作及运算实验报告.pdf
11-12
数据结构实验报告主要探讨了二叉树的基本操作和运算，这是计算机科学中数据结构课程的重要内容，特别是对于理解和实现非线性数据结构至关重要。二叉树是一种特殊的树形结构，每个节点最多有两个子节点，通常分为左子...
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
二叉树的基本操作（总结）
ParadiseHeaven的博客
11-21 1142
二叉树的基本操作 二叉树的定义决定了其大多数操作都可以由递归去实现 本文通过递归和非递归两种方式实现二叉树的基本操作（加深对原理的理解） 1.二叉树的声明   typedef char ElementType; typedef struct TreeNode* BinTree; struct TreeNode{ ElementType Data; struct Tre...
数据结构——哈夫曼树
yxl_d的博客
04-14 8069
一.简介 给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的路径长度是从树根到每一结点的路径长度之和，记为W...
并查集与高级数据结构——二叉树、线段树、树状数组
二叉树是计算机科学中的基本数据结构，包含二叉搜索树、Treap树和伸展树（Splay Tree）等变种。二叉搜索树保证左子树的所有元素小于根节点，右子树的所有元素大于根节点，这使得搜索、插入和删除操作的效率较高。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值