实验四 二叉树的基本操作
二叉树的基本操作

二叉树的基本操作二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
二叉树在计算机领域中得到广泛应用,它的基本操作包括插入、删除、查找、遍历等。
1.插入操作:二叉树的插入操作是将一个新的节点添加到已有的二叉树中的过程。
插入操作会按照一定规则将新节点放置在正确的位置上。
插入操作的具体步骤如下:-首先,从根节点开始,比较新节点的值与当前节点的值的大小关系。
-如果新节点的值小于当前节点的值,则将新节点插入到当前节点的左子树中。
-如果新节点的值大于当前节点的值,则将新节点插入到当前节点的右子树中。
-如果当前节点的左子树或右子树为空,则直接将新节点插入到该位置上。
-如果当前节点的左子树和右子树都不为空,则递归地对左子树或右子树进行插入操作。
2.删除操作:二叉树的删除操作是将指定节点从二叉树中删除的过程。
删除操作有以下几种情况需要考虑:-如果待删除节点是叶子节点,则直接将其从二叉树中删除即可。
-如果待删除节点只有一个子节点,则将其子节点替换为待删除节点的位置即可。
-如果待删除节点有两个子节点,则需要找到其左子树或右子树中的最大节点或最小节点,将其值替换为待删除节点的值,然后再删除最大节点或最小节点。
3.查找操作:二叉树的查找操作是在二叉树中查找指定值的节点的过程。
查找操作的具体步骤如下:-从根节点开始,将待查找值与当前节点的值进行比较。
-如果待查找值等于当前节点的值,则返回该节点。
-如果待查找值小于当前节点的值,则在当前节点的左子树中继续查找。
-如果待查找值大于当前节点的值,则在当前节点的右子树中继续查找。
-如果左子树或右子树为空,则说明在二叉树中找不到该值。
4.遍历操作:二叉树的遍历操作是按照一定规则依次访问二叉树中的每个节点。
有三种常用的遍历方式:- 前序遍历(Preorder Traversal):先访问根节点,然后递归地前序遍历左子树和右子树。
- 中序遍历(Inorder Traversal):先递归地中序遍历左子树,然后访问根节点,最后递归地中序遍历右子树。
完整word版二叉树基本操作 实验报告

一、实验目的实验报告 1、 熟悉二叉树树的基本操作。
2、 掌握二叉树的实现以及实际应用。
3、 加深二叉树的理解,逐步培养解决实际问题的编程能力。
二、实验环境 1 台 WINDOWS 环境的 PC 机,装有 Visual C++ 6.0。
三、实验内容【问题描述】现需要编写一套二叉树的操作函数, 以便用户能够方便的利用这些函数来实现自己的应用。
其中操作函数包括: 创建二叉树CreateBTNode(*b,*str):根据二叉树括号表示法的字符串*str 生成对应的链 式存储结构。
输出二叉树 DispBTNode(*b):以括号表示法输出一棵二叉树。
查找结点FindNode(*b,x):在二叉树b 中寻找data 域值为x 的结点,并返回指向该结点 的指针。
求高度BTNodeDepth(*b):求二叉树b 的高度。
若二叉树为空,则其高度为0;否则,其 高度等于左子树与右子树中的最大高度加 求二叉树的结点个数 先序遍历的递归算法: 中序遍历的递归算法: 后序遍历递归算法: 1> 2> 3> 4>5> 6>7> 8>9> NodesCou nt(BTNode *b) void P reOrder(BTNode *b) void In Order(BTNode *b) void P ostOrder(BTNode *b) 层次遍历算法 void LevelOrder(BTNode *b) 【基本要求】实现以上9个函数。
主函数中实现以下功能: 创建下图中的树b 输出二叉树b 找到''节点,输出其左右孩子值 输出b 的高度输出b 的节点个数A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))程序:#in elude <stdio.h>#in elude <malloc.h> #defi ne MaxSize 100 typ edef char ElemT ype;typ edef struct node{ElemT ype data; structnode *lchild; struct node*rchild;} BTNode; /*数据元素*/ /*指向左孩子*/ /*指向右孩子*/void CreateBTNode(BTNode *&b,char *str);// 创建 BTNode *Fi ndNode(BTNode *b,ElemTy pe x);// 查找节点 int BTNodeHeight(BTNode *b);// 求高度void Dis pBTNode(BTNode *b);// 输出int NodesCount(BTNode *b);// 二叉树的结点个数void PreOrder(BTNode *b);// 先序遍历递归void InOrder(BTNode *b);// 中序遍历递归void PostOrder(BTNode *b);// 后序遍历递归void LevelOrder(BTNode *b);// 层次遍历〃创建void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],* p=NULL;int top=-1,k,j=O;char ch;输出b 的四种遍历顺序 上图转 叉树括号表示法为b=NULL;ch=str[j];while(ch!='\0'){switch(ch){case '(':t op++;St[t op]=p ;k=1;break;case ')':t op--;break;case ',':k=2;break;default: p=(BTNode *)malloc(sizeof(BTNode)); p->data=ch; p->lchild=p-> rchild=NULL; if(b==NULL) b=p;else{switch(k){case 1:St[t op]->lchild=p ;break;case 2:St[t op]->rchild=p ;break;}}} j++;ch=str[j];}}//输出void Dis pBTNode(BTNode *b){if(b!=NULL){prin tf("%c",b->data);if(b->lchild!=NULL||b->rchild!=NULL){prin tf("(");Dis pBTNode(b->lchild); if(b->rchild!=NULL)prin tf(",");Dis pBTNode(b->rchild); prin tf(")");〃查找节点BTNode *Fin dNode(BTNode *b,ElemTy pe x){BTNode *p;if(b==NULL)return b;else if(b->data==x)return b;else{p=Fi ndNode(b->lchild,x);if(p !=NULL)return p;elseretur n Fin dNode(b->rchild,x);//求高度int BTNodeHeight(BTNode *b){ int lchildh,rchildh; if(b==NULL)return (0);else{lchildh=BTNodeHeight(b->lchild); rchildh=BTNodeHeight(b->rchild); return(lchildh>rchildh)?(lchildh+1):(rchildh+1);〃二叉树的结点个数int NodesCou nt(BTNode *b){ if(b==NULL)return 0;elsereturn NodesCou nt(b->lchild)+NodesCou nt(b->rchild)+1;//先序遍历递归void P reOrder(BTNode *b){ if(b!=NULL){prin tf("%c",b->data); PreOrder(b->lchild); PreOrder(b->rchild);〃中序遍历递归void InO rder(BTNode *b){ if(b!=NULL){InO rder(b->lchild); prin tf("%c",b->data); InO rder(b->rchild);}}//后序遍历递归void P ostOrder(BTNode*b){ if(b!=NULL){P ostOrder(b->lchild);P ostOrder(b->rchild); prin tf("%c",b->data);}}//层次遍历void LevelOrder(BTNode *b){BTNode *p;BTNode *qu[MaxSize];int fron t,rear;fron t=rear=-1;rear++;qu[rear]=b;while(fro nt!=rear){fron t=(fro nt+1)%MaxSize;p=qu[fron t];prin tf("%c", p->data);if(p->lchild!=NULL){rear=(rear+1)%MaxSize; qu[rear]=p->lchild;}if(p->rchild!=NULL){ rear=(rear+1)%MaxSize; qu[rear]=p-> rchild; void mai n()BTNode *b,* p, *l p,*rp;char str[]="A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,l)))";// 根据树形图改写成的〃二叉树括号表示法的字符串 *str//char str[100];sca nf("%s",& str);// 自行输入括号表示的二叉树CreateBTNode(b,str); // 创建树 b prin tf("\n");printf (”输出二叉树:");//输出二叉树bDis pBTNode(b);prin tf("\n");printf("'H'结点:");//找到'H'节点,输出其左右孩子值 p=Fi ndNode(b,'H');prin tf("\n");if (p !=NULL){printf("左孩子节点的值");prin tf("%c", p->lchild->data); prin tf("\n");printf("右孩子节点的值");prin tf("%c", p->rchild->data); prin tf("\n");//此处输出p 的左右孩子节点的值}prin tf("\n");printf (” 二叉树 b 的深度:%d\n",BTNodeHeight(b));// 输出 b 的高度 printf (”二叉树b 的结点个数:%d\n",NodesCount(b));//输出b 的节点个数 prin tf("\n");先序遍历序列:\n");//输出b 的四种遍历顺序算法:");PreOrder(b);printf("\n"); 中序遍历序列:\n"); 算法:");InOrder(b);printf("\n"); 后序遍历序列:\n"); 算法:");PostOrder(b);printf("\n"); 层次遍历序列:\n"); 算法:”);LevelOrder(b); printf("\n");printf (”printf (”printf (”printf (”printf (”printf (”printf (”四、实验心得与小结通过实验,我熟悉二叉树树的基本操作,掌握二叉树的实现以及实际应用。
实验四 二叉树操作实现

实验四二叉树操作实现
一、目的:
掌握二叉树的定义、性质及存储方式,各种遍历算法。
二、要求:
采用二叉树链表作为存储结构,完成二叉树的建立,先序、中序和后序以及按层次遍历的操作,求所有叶子及结点总数的操作。
三、实验内容
1、二叉树的基本操作。
2、调试程序,设计一棵二叉树,输入完全二叉树的先序序列,用#代表虚结点(空指针),
如ABD###CE##F##,建立二叉树,求出先序、中序和后序以及按层次遍历序列,求所有叶子及结点总数。
四、实验报告要求
要求所编的程序能正确运行,并提交实验报告。
实验报告的基本要求为:
1、陈述程序设计的任务,强调程序要做什么,明确规定:
(1)输入的形式和输出值的范围;
(2)输出的形式;
(3)程序所能达到的功能;
(4)测试数据:包括正确的输入输出结果和错误的输入及输出结果。
2、说明用到的数据结构定义、主程序的流程及各程序模块之间的调用关系。
3、提交带注释的源程序或者用伪代码写出每个操作所涉及的算法。
4、调试分析:
(1)调试过程中所遇到的问题及解决方法;
(2)算法的时空分析;
(3)经验与体会。
5、用户使用说明:说明如何使用你的程序,详细列出每一步操作步骤。
6、测试结果:列出对于给定的输入所产生的输出结果。
数据结构实验报告(四)

《数据结构》实验报告班级:学号:姓名:实验四二叉树的基本操作实验环境:Visual C++实验目的:1、掌握二叉树的二叉链式存储结构;2、掌握二叉树的建立,遍历等操作。
实验内容:通过完全前序序列创建一棵二叉树,完成如下功能:1)输出二叉树的前序遍历序列;2)输出二叉树的中序遍历序列;3)输出二叉树的后序遍历序列;4)统计二叉树的结点总数;5)统计二叉树中叶子结点的个数;实验提示://二叉树的二叉链式存储表示typedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;一、程序源代码#include <stdio.h>#include <stdlib.h>#define MAXSIZE 30typedef char ElemType;typedef struct TNode *BiTree;struct TNode {char data;BiTree lchild;BiTree rchild;};int IsEmpty_BiTree(BiTree *T) { if(*T == NULL)return 1;elsereturn 0;}void Create_BiTree(BiTree *T){char ch;ch = getchar();//当输入的是"#"时,认为该子树为空if(ch == '#')*T = NULL;//创建树结点else{*T = (BiTree)malloc(sizeof(struct TNode)); (*T)->data = ch; //生成树结点//生成左子树Create_BiTree(&(*T)->lchild);//生成右子树Create_BiTree(&(*T)->rchild);}}void TraverseBiTree(BiTree T) { //先序遍历if(T == NULL)return;else {printf("%c ",T->data);TraverseBiTree(T->lchild);TraverseBiTree(T->rchild);}}void InOrderBiTree(BiTree T) { //中序遍历if(NULL == T)return;else {InOrderBiTree(T->lchild);printf("%c ",T->data);InOrderBiTree(T->rchild);}}void PostOrderBiTree(BiTree T) {if(NULL == T)return;else {InOrderBiTree(T->lchild);InOrderBiTree(T->rchild);printf("%c ",T->data);}}int TreeDeep(BiTree T) {int deep = 0;if(T){int leftdeep = TreeDeep(T->lchild);int rightdeep = TreeDeep(T->rchild);deep = leftdeep+1 > rightdeep+1 ? leftdeep+1 : rightdeep+1;}return deep;}int Leafcount(BiTree T, int &num) {if(T){if(T->lchild ==NULL && T->rchild==NULL){num++;printf("%c ",T->data);}Leafcount(T->lchild,num);Leafcount(T->rchild,num);}return num;}void LevelOrder_BiTree(BiTree T){//用一个队列保存结点信息,这里的队列采用的是顺序队列中的数组实现 int front = 0;int rear = 0;BiTree BiQueue[MAXSIZE];BiTree tempNode;if(!IsEmpty_BiTree(&T)){BiQueue[rear++] = T;while(front != rear){//取出队头元素,并使队头指针向后移动一位tempNode = BiQueue[front++];//判断左右子树是否为空,若为空,则加入队列 if(!IsEmpty_BiTree(&(tempNode->lchild))) BiQueue[rear++] = tempNode->lchild;if(!IsEmpty_BiTree(&(tempNode->rchild))) BiQueue[rear++] = tempNode->rchild;printf("%c ",tempNode->data);}}}int main(void){BiTree T;BiTree *p = (BiTree*)malloc(sizeof(BiTree));int deepth,num=0 ;Create_BiTree(&T);printf("先序遍历二叉树:\n");TraverseBiTree(T);printf("\n");printf("中序遍历二叉树:\n");InOrderBiTree(T);printf("\n");printf("后序遍历二叉树:\n");PostOrderBiTree(T);printf("\n层次遍历结果:");LevelOrder_BiTree(T);printf("\n");deepth=TreeDeep(T);printf("树的深度为:%d",deepth);printf("\n");printf("树的叶子结点为:");Leafcount(T,num);printf("\\n树的叶子结点个数为:%d",num);return 0;}二、运行结果(截图)三、遇到的问题总结通过死循环的部分可以看出,在判断时是不能进入结点为空的语句中的,于是从树的构建中寻找问题,最终发现这一条语句存在着问题:这里给T赋值为空,也就是给整个结构体地址赋值为空,但是我们的目的是给该结构体中的内容,即左孩子的地址指向的内容赋为空。
数据结构实验四-二叉树基本操作

1、请分别统计教材P161图6.10(a)和P163图6.12中两棵二叉树中每种类型结点数(度为0、1、2的结点数)。
要求:
运行时输入多棵二叉树,验证输出结果的正确性。
将每组输入数据对应的二叉树画出来。
2、分别输入教材P164图6.14(a)和P163图6.12中有5个结点和8个结点的二叉树,编程序输出先序、中序和后序的遍历结果。
要求:
将每组输入数据对应的二叉树画出来。
认真理解程序并分析程序的运行结果的正确性。
3、完成教材P193例题6.6的哈夫曼树及哈夫曼编码。
要求:
输入一组权值,验证程序构造成的哈夫曼树及其编码的正确性。
画出对应输入权值的哈夫曼树。
认真理解程序并分析程序的运行结果的正确性。
题目二:。
实验四-二叉树操作实现

实验四-二叉树操作实现实验四二叉树操作实现实验日期:2017 年 4 月20 日实验目的及要求1. 熟练掌握树的基本概念、二叉树的基本操作及在链式存储结构上的实现;2. 重点掌握二叉树的创建、遍历及求深度等算法;3. 掌握运用递归方式描述算法及编写递归C程序的方法,提高算法分析和程序设计能力。
实验内容键盘输入一个字符串,利用二叉树前序遍历的结果建成一棵二叉树,并用三种遍历方法打印,比较是否与自己预先想象的相一致。
再求树的深度、1度结点数、2度节点数,交换二叉树的左右子树并输出交换后的中序遍历结果验证交换的正确性。
找到二叉树中序遍历最后一个结点并输出结点值。
二叉树结点类型定义:typedef char datatype;typedef struct tnode{datatype data;struct tnode *lchild,*rchild;} BiTNode,*BiTree;任务1.题目要求创建一个程序文件sy4.cpp,自定义相应函数完成以下操作:(1)void visit(BiTree p) /*输出p指针指向的结点*/(2)void Preorder(BiTree T) /*前序遍历*/(3)void Inorder(BiTree T) /*中序遍历*/(4)void Postorder(BiTree T) /*后序遍历*/(5)BiTree CreateTree( ) /*以前序遍历的顺序建立二叉树*/(6)int deep(BiTree T) /*求二叉树深度*/(7)int leaf(BiTree T) /*求叶子结点数*/(8)int OneChild(BiTree T) /*求1度结点数*/(9)int TwoChild(BiTree T) /*求2度结点数*/(10)void Exchange(BiTree T) /*二叉树左右子树交换*/(11)BiTree InorderLastNode(BiTree T); /*找二叉树中序遍历最后一个结点*/2.请回答下列问题(1)在n个结点二叉树的二叉链表存储中,其指针域的总数为2n 个,其中n-1 个用于链接孩子结点,n+1 个空闲着。
二叉树的基本操作实验报告

二叉树的基本操作实验报告学号姓名实验日期 2012-12-26实验室计算机软件技术实验指导教师设备编号 401实验内容二叉树的基本操作一实验题目实现二叉树的基本操作的代码实现二实验目的1、掌握二叉树的基本特性2、掌握二叉树的先序、中序、后序的递归遍历算法3、通过求二叉树的深度、度为2的结点数和叶子结点数等算法三实习要求(1)认真阅读书上给出的算法(2)编写程序并独立调试四、给出二叉树的抽象数据类型ADT BinaryTree{//数据对象D:D是具有相同特性的数据元素的集合。
//数据关系R:// 若D=Φ,则R=Φ,称BinaryTree为空二叉树;// 若D?Φ,则R={H},H是如下二元关系;// (1)在D中存在惟一的称为根的数据元素root,它在关系H下无前驱; // (2)若D-{root}?Φ,则存在D-{root}={D1,Dr},且D1?Dr =Φ; // (3)若D1?Φ,则D1中存在惟一的元素x1,<root,x1>?H,且存在D1上的关系H1 ?H;若Dr?Φ,则Dr中存在惟一的元素xr,<root,xr>?H,且存在上的关系Hr ?H;H={<root,x1>,<root,xr>,H1,Hr};// (4)(D1,{H1})是一棵符合本定义的二叉树,称为根的左子树;(Dr,{Hr})是一棵符合本定义的二叉树,称为根的右子树。
//基本操作:CreateBiTree( &T, definition ) // 初始条件:definition给出二叉树T的定义。
// 操作结果:按definiton构造二叉树T。
BiTreeDepth( T )// 初始条件:二叉树T存在。
// 操作结果:返回T的深度。
PreOrderTraverse( T, visit() ) // 初始条件:二叉树T存在,Visit是对结点操作的应用函数。
二叉树的各种基本运算的实现实验报告

二叉树的各种基本运算的实现实验报告
一、实验目的
实验目的为了深入学习二叉树的各种基本运算,通过操作实现二叉树的建立、存储、查找、删除、遍历等各种基本运算操作。
二、实验内容
1、构造一个二叉树。
我们首先用一定的节点来构建一棵二叉树,包括节点的左子节点和右子节点。
2、实现查找二叉树中的节点。
在查找二叉树中的节点时,我们根据二叉树的特点,从根节点开始查找,根据要查找的节点的值与根节点的值的大小的关系,来决定接下来查找的方向,直到找到要查找的节点为止。
3、实现删除二叉树中的节点。
在删除二叉树节点时,我们要做的是找到要删除节点的父节点,然后让父节点的链接指向要删除节点的子节点,有可能要删除节点有一个子节点,有可能有两个极点,有可能没有子节点,我们要根据每种情况进行处理,来保持二叉树的结构不变。
4、对二叉树进行遍历操作。
二叉树的遍历有多种方法,本实验使用的是先序遍历。
首先从根节点出发,根据先序遍历的顺序,先访问左子树,然后再访问右子树,最后访问根节点。
三、实验步骤
1、构建二叉树:
我们用一个数组代表要构建的二叉树,第一项为根节点,第二项和第三项是根节点的子节点。
数据结构二叉树的基本操作

数据结构与算法课程实验报告实验四:二叉树的基本操作姓名:沈靖雯班级:14信息与计算科学(2)班学号:2014326601094实验四二叉树的基本操作【实验内容】实现创建和遍历二叉树的基本操作【实验目的】掌握二叉树的定义和存储表示,学会建立一棵特定二叉树的方法;掌握二叉树的遍历算法(先序、中序、后序遍历算法)的思想,并学会遍历算法的递归实现和非递归实现。
【问题描述】(1)编程实现构造一棵二叉树的算法,适合任意合法输入的二叉树的建立,并进行相应异常处理。
(2)编程实现在二叉链表这种存储方式下,实现二叉的遍历,可采用递归或者非递归实现,遍历算法可在先序、中序和后序遍历算法中任选其一。
【问题实现】一、实现链队列基本运算(1)抽象数据类型ADT BTree {数据对象D: D是具有相同特性的数据元素的集合。
基本操作:CreatBiTree(*T)操作结果:构造二叉树T。
PreOrderTraverse(T)初始条件:二叉树T已存在。
操作结果:先序遍历T。
InOrderTraverse(T)初始条件:二叉树T已存在。
操作结果:中序遍历T。
PostOrderTraverse(T)初始条件:二叉树T已存在。
操作结果:后序遍历T。
} ADT BTree(2)主要实现思路与主要程序代码:1).首先定义二叉树结点结构;typedef struct Node{char data;struct Node *lchild,*rchild; //左右孩子指针}BiTNode,*BTree;2).其次定义一个二叉树构造函数int CreatBiTree(BTree *T);采用递归先序法构造二叉树;scanf("%c",&ch);if(ch==' ')*T=NULL;//T为空二叉树else{if(!(*T=(BTree)malloc(sizeof(BiTNode)))) return (OVERFLOW);(*T)->data=ch;CreatBiTree(&((*T)->lchild));CreatBiTree(&((*T)->rchild));}3).定义遍历函数(递归先序为例);//先序遍历二叉树,递归实现void PreOrderTraverse(BTree T){if(T){ printf("%c ",T->data);PreOrderTraverse (T->lchild);PreOrderTraverse (T->rchild);}}这里用printf代替visit(),简化程序代码;4).定义主函数,总体完成以上所有函数功能的实现(构建二叉树与遍历二叉树)。
数据结构与算法实验——二叉树基本操作

二叉树基本操作实验报告实验名称二叉树基本操作实验目的1.熟悉二叉树结点的结构和二叉树的基本操作;2.掌握二叉树每种操作的具体实现;3.学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法;4.在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法;5.掌握构造哈夫曼树以及哈夫曼编码的方法。
实验内容编制一个演示二叉树创建、遍历、计算等操作的程序。
问题描述用数据结构相关知识,实现二叉树的定义和操作。
该程序包括二叉树结构类型以及对二叉树操作的具体的函数定义(包括:初始化二叉树、清空二叉树、检查二叉树是否为空、遍历二叉树(先序、后序、中序、层次)、求二叉树的深度、求二叉树所有节点数)。
问题分析该实验是基于C语言和数据结构知识基础的对二叉树的基本操作的检验,无需设计复杂的算法,程序语句也相对简单。
因此,我直接按要求定义了对二叉树操作的具体函数,并于主函数中实现对应的功能调用,其中,功能选择靠switch语句实现。
实验步骤1.需求分析本演示程序用VC++编写,完成二叉树的生成、遍历、计算等基本操作。
①输入的形式和输入值的范围:以字符(其中‘#’表示虚节点)的形式输入,以创建二叉树;在输入二叉树节点前,必须先确定该序列能正确创建二叉树。
②输出的形式:在所有三种操作中都显示操作是否正确以及操作后二叉树的内容。
③程序所能达到的功能:完成二叉树的生成、遍历(包括先序、后序、中序、层次四种方式)、计算等基本操作。
④测试数据:创建操作中依次输入a,b,d,#,g,#,#,#,c,e,#,#,f,#,#生成一个二叉树。
2.概要设计1)为了实现上述程序功能,需要定义二叉树的抽象数据类型:ADT BitTree {数据对象:由一个根节点和两个互不相交的左右子树构成数据关系:结点具有相同的数据类型及层次结构基本操作:Void BinTreeInit(BitTree *T)初始条件:无操作结果:初始化一棵二叉树Void BinTreeCreat(BitTree *T)初始条件:二叉树T已存在操作结果:按先序次序创建一棵二叉树2)本程序包含7个函数:①主函数main() ②初始化二叉树函数BinTreeInit() ③建立一棵二叉树函数BinTreeCreat() ④先序遍历函数PreOrderTraverse() ⑤中序遍历函数InOrderTraverse()⑥后序遍历函数PostOrderTraverse()⑦层次遍历函数LevelOrderTraverse()⑧求二叉树深度函数Countlevel()⑨检验空树函数BinTreeEmpty()⑩求节点数函数 Countnode()函数说明#include<stdio.h>#include<stdlib.h>typedef char Datatype;typedef struct NodeType{Datatype data;struct NodeType *lchild;struct NodeType *rchild;}BiTNode;typedef BiTNode * BinTree;//初始化二叉树。
二叉树的基本操作实现(数据结构实验)

⼆叉树的基本操作实现(数据结构实验)实验题⽬:⼆叉树的基本操作实现实验⽬的:掌握⼆叉树的⼆叉链存储结构及表⽰。
掌握⼆叉树的三种遍历算法(递归和⾮递归两类)。
运⽤三种遍历的⽅法求解⼆叉树的有关问题。
实验内容:实现⼆叉树的⼆叉链表存储结构;实现先序、中序和后序遍历⼆叉树;遍历⼆叉树的应⽤:计算叶⼦结点、左右⼦树交换等。
要求:1、⼆叉树基本操作已实现,学习和进⼀步理解。
2 、在求总结点的程序中加⼊求叶⼦结点的功能。
3 、左右⼦树交换,按中序和后序是否也可以?4 、选作:按层遍历⼆叉树。
实验代码:#include<stdio.h>#include<malloc.h>#include<string.h>#include<stdlib.h>#include<iostream>#define MAXTSIZE 1000using namespace std;/*测试数据: abc##de#g##f###*/typedef struct BiTNode{char data; // 结点数据域struct BiTNode *lchild,*rchild; // 左右孩⼦指针}BiTNode,*BiTree;void CreateBiTree(BiTree &T) // 先序遍历建⽴⼆叉链表{char ch;cin>>ch;// scanf("%c",&ch);if(ch=='#')T=NULL;else{T=(BiTNode *)malloc(sizeof(BiTNode));T->data=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}void travel1(BiTree T) // 先序遍历{if(T){printf("%c",T->data);travel1(T->lchild);travel1(T->rchild);}}void travel2(BiTree T) // 中序遍历{if(T){travel2(T->lchild);printf("%c",T->data);travel2(T->rchild);}}void travel3(BiTree T) // 后序遍历{if(T){travel3(T->lchild);travel3(T->rchild);printf("%c",T->data);}}int count(BiTree T) // 计算叶⼦结点的个数{if(T==NULL) return0;int cnt=0;if((!T->lchild)&&(!T->rchild)){cnt++;}int leftcnt=count(T->lchild);int rightcnt=count(T->rchild);cnt+=leftcnt+rightcnt;return cnt;}int Depth(BiTree T) // 计算⼆叉树的深度{if(T==NULL) return0;else{int m=Depth(T->lchild);int n=Depth(T->rchild);return m>n?(m+1):(n+1);}}void exchange(BiTree T,BiTree &NewT) // 交换左右⼦树{if(T==NULL){NewT=NULL;return ;}else{NewT=(BiTNode *)malloc(sizeof(BiTNode));NewT->data=T->data;exchange(T->lchild,NewT->rchild); // 复制原树的左⼦树给新树的右⼦树 exchange(T->rchild,NewT->lchild); // 复制原树的右⼦树给新树的左⼦树 }}int main(){puts("**************************");puts("1. 建⽴⼆叉树");puts("2. 先序遍历⼆叉树");puts("3. 中序遍历⼆叉树");puts("4. 后序遍历⼆叉树");puts("5. 计算叶⼦结点个数");puts("6. 计算⼆叉树的深度");puts("7. 交换⼆叉树的左右⼦树");puts("0. 退出");puts("**************************");BiTree Tree,NewTree;int choose;while(~scanf("%d",&choose),choose){switch(choose){case1:puts("温馨提醒:输⼊请以 '#' 为左/右⼦树空的标志!");CreateBiTree(Tree);break;case2:printf("先序遍历结果为:");travel1(Tree);puts("");break;case3:printf("中序遍历结果为:");travel2(Tree);puts("");break;case4:printf("后序遍历结果为:");travel3(Tree);puts("");break;case5:printf("叶⼦结点个数为:%d\n",count(Tree));break;case6:printf("⼆叉树的深度为:%d\n",Depth(Tree));break;case7:exchange(Tree,NewTree);Tree=NewTree;puts("交换成功!\n");break;}}system("pause");return0;}。
二叉树的基本操作与实现实验报告

二叉树的基本操作与实现实验报告二叉树是一种重要的数据结构,在计算机科学领域中被广泛应用。
本实验将介绍二叉树的基本操作与实现,并给出相应的实验报告。
一、引言二叉树是一种特殊的树状结构,每个节点至多有两个子节点。
二叉树有许多重要的特性,如平衡二叉树、二叉树等,应用广泛。
在本实验中,我们将介绍二叉树的基本操作和实现。
二、实验目的1.掌握二叉树的基本概念和特性;2.熟悉二叉树的基本操作,包括创建、插入、删除、遍历等;3.学会使用编程语言实现二叉树的基本操作。
三、实验内容本实验主要包括以下内容:1.二叉树的定义和基本概念;2.二叉树的基本操作,包括创建、插入、删除、遍历等;3.使用编程语言实现二叉树的基本操作;4.测试和验证二叉树的基本操作的正确性。
四、实验步骤1.二叉树的定义和基本概念二叉树是一种树状结构,每个节点至多有两个子节点。
二叉树的每个节点包含一个数据项和指向左子树和右子树的指针。
二叉树的特性有很多,如完全二叉树、平衡二叉树、二叉树等。
2.二叉树的基本操作(1)创建二叉树:可以通过手动输入节点数据来创建二叉树,也可以通过读取文件中的数据来创建二叉树。
(2)插入节点:在指定位置插入一个新节点。
(3)删除节点:删除指定位置的节点。
(4)遍历二叉树:有前序遍历、中序遍历和后序遍历三种遍历方式。
3.使用编程语言实现二叉树的基本操作实现二叉树的基本操作可以使用编程语言来完成。
我们可以定义一个二叉树的结构体,包含节点数据和指向左右子树的指针。
然后根据具体的需求,实现相应的操作函数。
4.测试和验证二叉树的基本操作的正确性在完成二叉树的基本操作后,我们可以编写测试代码来验证操作的正确性。
通过创建二叉树,并进行插入、删除和遍历操作,观察输出结果是否符合预期。
五、实验结果与分析在完成二叉树的基本操作后,我们可以进行测试和验证。
通过输出二叉树的遍历结果,比对预期结果来判断操作是否正确。
同时,我们还可以观察二叉树的结构和特性,如是否满足平衡二叉树或二叉树的条件。
二叉树的基本操作实验报告

二叉树的基本操作实验报告二叉树的基本操作实验报告引言:二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。
二叉树的基本操作包括创建、遍历、插入和删除等。
本实验旨在通过实践来深入了解二叉树的基本操作,并通过实验结果验证其正确性和有效性。
一、创建二叉树创建二叉树是二叉树操作中的第一步。
在本实验中,我们使用了递归算法来创建二叉树。
递归算法是一种重要的算法思想,通过将问题划分为更小的子问题来解决复杂的问题。
在创建二叉树时,我们首先创建根节点,然后递归地创建左子树和右子树。
二、遍历二叉树遍历二叉树是对二叉树中的每个节点进行访问的过程。
常见的遍历方式有前序遍历、中序遍历和后序遍历。
前序遍历先访问根节点,然后递归遍历左子树和右子树;中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树;后序遍历先递归遍历左子树和右子树,最后访问根节点。
三、插入节点插入节点是向二叉树中添加新节点的操作。
插入节点的过程需要遵循二叉树的特性,即左子节点的值小于父节点的值,右子节点的值大于父节点的值。
在插入节点时,我们需要找到合适的位置,将新节点插入到正确的位置上。
四、删除节点删除节点是从二叉树中移除节点的操作。
删除节点的过程相对复杂,需要考虑多种情况。
如果要删除的节点是叶子节点,直接删除即可。
如果要删除的节点只有一个子节点,将其子节点连接到父节点上。
如果要删除的节点有两个子节点,我们需要找到其后继节点或前驱节点来替代被删除的节点。
实验结果:通过实验,我们成功地实现了二叉树的基本操作。
创建二叉树的递归算法能够正确地创建出符合要求的二叉树。
遍历二叉树的算法能够按照指定的顺序遍历每个节点。
插入节点和删除节点的操作也能够正确地修改二叉树的结构。
讨论与总结:二叉树的基本操作是数据结构中的重要内容,对于理解和应用其他数据结构具有重要意义。
通过本次实验,我们深入了解了二叉树的创建、遍历、插入和删除等操作,并通过实验验证了其正确性和有效性。
数据结构实验报告(二叉树的基本操作)

else LeafNum=LeafCount(root->LChild)+LeafCount(root->RChild);
//叶子数为左右子树数目之和
return LeafNum;
printf("\n菜单选择\n\n");
printf(" 1.树状输出二叉树2.先序遍历二叉树\n");
printf(" 3.中序遍历二叉树4.后序遍历二叉树\n");
printf(" 5.输出叶子结点6.输出叶子结点的个数\n");
printf(" 7.输出二叉树的深度8.退出\n");
printf("\n----------------------------------------------------------------------\n");
{
printf("\n\n");
j=j+1; k=0;
while(k<nlocate)
{
printf(" ");
k++;
}
}
while(k<(nlocate-1))
{
printf(" ");
k++;
}
printf("%c",bt->data );
q.front=q.front+1;
if(bt->LChild !=NULL)//存在左子树,将左子树根节点入队列
实验四 二叉树的基本操作

实验四二叉树的基本操作一、实验目的1.进一步掌握指针变量的含义。
2.掌握二叉树的结构特征,以及各种存储结构的特点及使用范围。
3.掌握用指针类型描述、访问和处理二叉树的运算。
二、实验要求1、设计二叉树的基本操作;2、写出相应程序;3、保存和打印出程序的运行结果,并结合程序进行分析。
三、实验内容给出一个可进行二叉树基本操作的完整程序,具有以下功能:(1)根据输入字符序列,建立二叉树;(2)用递归算法实现输出二叉树的前序、中序、后序遍历序列;(3)求二叉树的高度。
附加题: (有时间可继续完成下面内容)(4)用非递归算法实现输出二叉树的前序、中序遍历序列;(5)求二叉树的叶子个数;(6)求度为1的结点的个数;算法:四、程序代码建树,遍历,求树高#include<stdio.h>#include<string.h>#include<stdlib.h>typedef struct Node{char data;struct Node * lchild;struct Node * rchild;}Node,*Tree;void a(Tree & t){ //构造二叉树char ch;scanf("%c",&ch);if(ch=='.')t=NULL;else{t=(Tree)malloc(sizeof(Node));t->data=ch;a(t->lchild);a(t->rchild);}return;}void b(Tree & t){ //先序遍历if(t){printf("%c",t->data);b(t->lchild);b(t->rchild);}}void c(Tree & t){ //中序遍历if(t){c(t->lchild);printf("%c",t->data);c(t->rchild);}}void d(Tree & t){ //后序遍历if(t){d(t->lchild);d(t->rchild);printf("%c",t->data);}}int max(int x,int y){return x>y?x:y;}int high(Tree & t){if(t==NULL)return 0;elsereturn max(high(t->lchild),high(t->rchild))+1;}int main(){Tree t;printf("请输入二叉树:\n");a(t);printf("\n先序遍历 \n\n");b(t);printf("\n\n中序遍历 \n\n");c(t);printf("\n\n后序遍历 \n\n");d(t);printf("\n\n树高为:%d",high(t));}非递归先序,中序遍历,求叶子节点的个数,求度为1的节点的个数#include<stdio.h>#include<string.h>#include<stdlib.h>typedef struct Node{char data;struct Node * lchild;struct Node * rchild;}Node,*Tree;void a(Tree & t){ //构造二叉树char ch;scanf("%c",&ch);if(ch=='.')t=NULL;else{t=(Tree)malloc(sizeof(Node));t->data=ch;a(t->lchild);a(t->rchild);}return;}void b(Tree t){Tree stack[20], p;int top = -1;if (t != NULL){top++;stack[top] = t;while (top > -1){p = stack[top];top--;printf("%c ", p->data);if (p->rchild != NULL){top++;stack[top] = p->rchild; }if (p->lchild != NULL){top++;stack[top] = p->lchild; }}printf("\n");}}void c(Tree t){Tree stack[20], p;int top = -1;if (t != NULL){p = t;while (top > -1 || p != NULL) {while (p != NULL){top++;stack[top] = p;p = p->lchild;}if (top > -1){p = stack[top];top--;printf("%c ", p->data);p = p->rchild;}}printf("\n");}}void d(Tree & t,int & n){if(t){if(!t->lchild&&!t->rchild)n++;d(t->lchild,n);d(t->rchild,n);}}void e(Tree & t,int & n){if(t){if((!t->lchild&&t->rchild)||(t->lchild&&!t->rchild)) n++;e(t->lchild,n);e(t->rchild,n);}}int main(){Tree t;int n1=0,n2=0;printf("请输入二叉树:\n");a(t);printf("先序非递归遍历:\n");b(t);printf("中序非递归遍历:\n");c(t);d(t,n1);printf("叶子节点的个数:%d\n",n1);e(t,n2);printf("度为1的点的个数:%d\n",n2);}五、结果及分析递归遍历,树高非递归遍历,叶子节点个数,度为1的节点个数。
实验四:二叉树的基本操作和应用

while(1)
{
scanf("%d",&i);
if(i==1)
{
printf("Preorder :");
PreOrder(root);
printf("\n");
}
if(i==2)
{
struct Node * RChild;
}BiTree;
BiTree* BuildTree(BiTree *B)
{
char ch;
ch=getchar();
if(ch=='0')
B=NULL;
else
{
B=(BiTree *)malloc(sizeof(BiTree));
B->data=ch;
B->LChild=BuildTree(B->LChild);
{
PostOrder(root ->LChild);
PostOrder(root ->RChild);
printf("%c",root->data);
}
}
void End(BiTree *root)
{
printf("End");
}
void Set(BiTree *root)
{ int i;
printf("*********************************************\n");
B->RChild=BuildTree(B->RChild);
实验 4:二叉树的操作

实验4:二叉树的操作
【问题描述】
二叉树是一种常用的非线性数据结构。
设计一个程序,实现对二叉树的创建、遍历、计算等操作。
【实验目的】
递归过程是如何执行的?递归程序该如何编写?――这一直是困惑学生的问题。
通过对二叉树操作的练习,使学生增加对递归过程的感性认识,从而帮助他们理解递归方法,提高编写递归程序的能力。
【基本要求】
(1)创建二叉树
(2)实现对二叉树的先序、中序、后序和按层次遍历
(3)实现对二叉数的各种运算,如结点总数、叶子数、深度、宽度等
(4)实现二叉树的其他操作,如找已知结点的双亲、孩子、兄弟、祖先,复制二叉树等
【实现提示】
(1) 二叉树用二叉链表表示:
BiTNode{
Bitypedef
struct
ElemType data;
*rchild;
struct
BiTNode *lchild,
BiTNode,
*BiTree;
}
(2)创建二叉树可以通过输入能够唯一定义一棵二叉树的序列,如:扩展二叉树的先序序列、
扩展二叉树的后序序列、二叉树的先序序列和中序序列、二叉树的后序序列和中序序列、扩展二叉树的按层次遍历序列等
(3)可以采用多级菜单的操作界面
(4)可以创建多棵二叉树,用一个指针数组来管理这些二叉树的树根指针
【选做内容】
借助于栈,用非递归的方法实现对二叉树的遍历、运算或操作。
二叉树的操作实验报告

二叉树的操作实验报告
实验报告:二叉树的操作
引言:
二叉树是计算机科学中最基础、最重要的数据结构之一,它不仅在算法设计与分析中被广泛应用,而且也在计算机系统和软件工程领域被广泛使用。
在这次实验中,我们将学习和实现二叉树的基本操作,包括二叉树的建立、遍历、查找和删除等。
实验过程:
1. 二叉树的建立
2. 二叉树的遍历
3. 二叉树的查找
4. 二叉树的删除
实验结果:
1. 建立一颗二叉树,根节点为A,左子树B,右子树C,B的左子树D,右子树E,C的左子树F,右子树G。
结构如下:
A
/ \
B C
/ \ / \
D E F G
2. 对上述二叉树先进行中序遍历:DBEAFCG,再进行前序遍历:ABDECFG,最后进行后序遍历:DEBFGCA。
3. 在上述二叉树中查找元素G,并输出其父节点元素C。
4. 删除上述二叉树中的元素F,再对其进行中序遍历,结果为DBEACG。
结论:
通过这次实验,我们掌握了二叉树的基本操作方法,对于理解和分析算法、编写系统和软件工程都具有重要的意义。
同时,在实践中我们也深刻地认识到了二叉树操作的复杂性和局限性,这需要我们在实际应用中加以考虑和综合利用,才能发挥其最大的价值和作用。
数据结构 实验四 二叉树的基本操作

实验四二叉树的基本操作一、实验目的:(1)掌握二叉树的定义和存储表示,学会建立一棵特定二叉树的方法;(2)掌握二叉树的遍历算法(先序、中序、后序遍历算法)的思想;(3)掌握二叉树和叶子数、深度之间的关系及联系。
二、实验内容:构造二叉树,再实现二叉树的先序、中序、后序遍历,最后统计二叉树的叶子数和深度。
三、实验步骤:(一) 需求分析1. 二叉树的建立首先要建立一个二叉链表的结构体,包含根节点和左右子树。
因为树的每一个左右子树又是一颗二叉树,所以用递归的方法来建立其左右子树。
二叉树的遍历是一种把二叉树的每一个节点访问并输出的过程,遍历时根结点与左右孩子的输出顺序构成了不同的遍历方法,这个过程需要按照不同的遍历的方法,先输出根结点还是先输出左右孩子,可以用选择语句来实现。
2.程序的执行命令为:1)构造结点类型,然后创建二叉树。
2)根据提示,从键盘输入各个结点。
3)通过选择一种方式(先序、中序或者后序)遍历。
4)输出结果,结束。
(二)概要设计1.二叉树的二叉链表结点存储类型定义typedef struct Node {DataType data;struct Node *LChild;struct Node *RChild;}BitNode,*BitTree;2.建立如下图所示二叉树:3.本程序包含六个模块1) 主程序模块2)先序遍历模块3)中序遍历模块4)后序遍历模块5)叶子数模块6)深度模块四、测试结果1. 进入演示程序后的显示主界面:请输入二叉树中的元素;先序、中序、后序遍历和叶子数、深度分别输出结果。
2.测试结果以扩展先序遍历序列输入,其中#代表空子树:ABC##DE#G##F### 先序遍历序列为:ABCDEGF中序遍历序列为:CBEGDFA后序遍历序列为:CGEFDBA此二叉树的叶子数为:3此二叉树的深度为:53.程序运行结果截图:五、源代码#include#include//节点声明,数据域、左孩子指针、右孩子指针typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;//先序建立二叉树BiTree CreateBiTree(){char ch;BiTree T;scanf("%c",&ch);if(ch=='#')T=NULL;else{T = (BiTree)malloc(sizeof(BiTNode));T->data = ch;T->lchild = CreateBiTree();T->rchild = CreateBiTree();}return T;//返回根节点}//先序遍历void PreOrderTraverse(BiTree T){ if(T){printf("%c",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}//中序遍历void InOrderTraverse(BiTree T){ if(T){InOrderTraverse(T->lchild);printf("%c",T->data);InOrderTraverse(T->rchild);}}//后序遍历void PostOrderTraverse(BiTree T){ if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c",T->data);}}//求二叉树的深度int Depth(BiTree T){int dep=0,depl,depr;if(!T) dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}//计算叶子节点数int leef(BiTree T){if(!T)return 0;elseif(T->lchild ==NULL&&T->rchild ==NULL)return 1;elsereturn leef(T->lchild) +leef(T->rchild );}//主函数void main(){BiTree T;printf("请按先序输入序列(其中的“#”表示空)\n\n");T = CreateBiTree();//建立二叉树printf("\n先序遍历结果为:");PreOrderTraverse(T);//先序遍历输出printf("\n\n中序遍历结果为:");InOrderTraverse(T);//中序遍历输出printf("\n\n后序遍历结果为:");PostOrderTraverse(T);//后序遍历输出printf("\n\n二叉树深度为:%d\n",Depth(T)); Depth(T);//计算二叉树深printf("\n叶子节点数为:%d\n\n",leef(T)); leef(T);//计算叶子节点数}。
二叉树基本操作

二叉树基本操作二叉树基本操作一、实验目的1.熟悉二叉树结点的结构和对二叉树的基本操作。
2.掌握对二叉树每一种操作的具体实现。
3.学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
4.在二叉树基本操作的基础上掌握对二叉树的一些其它操作的具体实现方法。
5.掌握构造哈夫曼树以及哈夫曼编码的方法。
二、实验内容(必做1)程序 1该程序的功能是实现二叉树结点的类型定义和对二叉树的基本操作。
该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。
/* 定义 DataType 为char类型 */typedef char DataType;/* 二叉树的结点类型 */typedef struct BitNode{DataType data;struct BitNode *lchild,*rchild;}BitNode,*BitTree;/* 初始化二叉树,即把树根指针置空 */void BinTreeInit(BitTree *BT)/* 按先序次序建立一个二叉树*/void BinTreeCreat(BitTree *BT)/* 检查二叉树是否为空 */int BinTreeEmpty(BitTree *BT)/* 按任一种遍历次序(包括按先序、中序、后序、按层次)输出二叉树中的所有结点 */void BinTraverse(BitTree *BT)/* 求二叉树的深度 */int BinTreeDepth(BitTree BT)/* 求二叉树中所有结点数 */int BinTreeCount(BitTree BT)/* 清除二叉树,使之变为空树 */void BinTreeClear(BitTree *BT)程序2 二叉树采用二叉链表存储,设计按层次遍历二叉树的算法。
设计要求:在程序中构造两个子程序分别为void BinTreeCreat(BitTree *BT) /* 按前序次序建立一个二叉树*/ void layorder(BitTree T) /*按层次遍历二叉树 */程序 3哈夫曼树和哈夫曼编码:从终端输入若干个字符,统计字符出现的频率,将字符出现的频率作为结点的权值,建立哈夫曼树,然后对各字符进行哈夫曼编码。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实用文档
实验四二叉树的基本操作
一、实验目的
1.进一步掌握指针变量的含义。
2.掌握二叉树的结构特征,以及各种存储结构的特点及使用范围。
3.掌握用指针类型描述、访问和处理二叉树的运算。
二、实验要求
1、设计二叉树的基本操作;
2、写出相应程序;
3、保存和打印出程序的运行结果,并结合程序进行分析。
三、实验内容
给出一个可进行二叉树基本操作的完整程序,具有以下功能:
(1)根据输入字符序列,建立二叉树;
(2)用递归算法实现输出二叉树的前序、中序、后序遍历序列;
(3)求二叉树的高度。
附加题: (有时间可继续完成下面内容)
(4)用非递归算法实现输出二叉树的前序、中序遍历序列;
(5)求二叉树的叶子个数;
(6)求度为1的结点的个数;
算法:
四、程序代码
建树,遍历,求树高
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node{
char data;
struct Node * lchild;
struct Node * rchild;
}Node,*Tree;
void a(Tree & t){ //构造二叉树
char ch;
scanf("%c",&ch);
if(ch=='.')
实用文档
t=NULL;
else{
t=(Tree)malloc(sizeof(Node));
t->data=ch;
a(t->lchild);
a(t->rchild);
}
return;
}
void b(Tree & t){ //先序遍历
if(t){
printf("%c",t->data);
b(t->lchild);
b(t->rchild);
}
}
void c(Tree & t){ //中序遍历
if(t){
c(t->lchild);
printf("%c",t->data);
c(t->rchild);
}
}
void d(Tree & t){ //后序遍历
if(t){
d(t->lchild);
d(t->rchild);
printf("%c",t->data);
}
}
int max(int x,int y)
{
return x>y?x:y;
}
int high(Tree & t)
{
if(t==NULL)
return 0;
else
return max(high(t->lchild),high(t->rchild))+1;
}
int main(){
Tree t;
printf("请输入二叉树:\n");
a(t);
printf("\n先序遍历 \n\n");
b(t);
printf("\n\n中序遍历 \n\n");
c(t);
printf("\n\n后序遍历 \n\n");
d(t);
printf("\n\n树高为:%d",high(t));
}
非递归先序,中序遍历,求叶子节点的个数,求度为1的节点的个数
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Node{
char data;
struct Node * lchild;
struct Node * rchild;
}Node,*Tree;
void a(Tree & t){ //构造二叉树
char ch;
scanf("%c",&ch);
if(ch=='.')
t=NULL;
else{
t=(Tree)malloc(sizeof(Node));
t->data=ch;
a(t->lchild);
a(t->rchild);
}
return;
}
void b(Tree t)
{
Tree stack[20], p;
int top = -1;
if (t != NULL)
{
top++;
stack[top] = t;
while (top > -1)
{
p = stack[top];
top--;
printf("%c ", p->data);
if (p->rchild != NULL)
{
top++;
stack[top] = p->rchild; }
if (p->lchild != NULL)
{
top++;
stack[top] = p->lchild; }
}
printf("\n");
}
}
void c(Tree t)
{
Tree stack[20], p;
int top = -1;
if (t != NULL)
{
p = t;
while (top > -1 || p != NULL) {
while (p != NULL)
{
top++;
stack[top] = p;
p = p->lchild;
}
if (top > -1)
{
p = stack[top];
top--;
printf("%c ", p->data);
p = p->rchild;
}
}
printf("\n");
}
}
void d(Tree & t,int & n){
if(t){
if(!t->lchild&&!t->rchild)
n++;
d(t->lchild,n);
d(t->rchild,n);
}
}
void e(Tree & t,int & n){
if(t){
if((!t->lchild&&t->rchild)||(t->lchild&&!t->rchild)) n++;
e(t->lchild,n);
e(t->rchild,n);
}
}
int main(){
Tree t;
int n1=0,n2=0;
printf("请输入二叉树:\n");
a(t);
printf("先序非递归遍历:\n");
b(t);
printf("中序非递归遍历:\n");
c(t);
d(t,n1);
printf("叶子节点的个数:%d\n",n1);
e(t,n2);
printf("度为1的点的个数:%d\n",n2);
}
五、结果及分析
递归遍历,树高
非递归遍历,叶子节点个数,度为1的节点个数。