二叉树的建立和遍历的实验报告doc

合集下载

完整word版二叉树基本操作 实验报告

完整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 (”四、实验心得与小结通过实验,我熟悉二叉树树的基本操作,掌握二叉树的实现以及实际应用。

(完整word版)二叉树遍历 实验报告

(完整word版)二叉树遍历  实验报告

数据结构实验报告报告题目:二叉树的基本操作学生班级:学生姓名:学号:一.实验目的1、基本要求:深刻理解二叉树性质和各种存储结构的特点及适用范围;掌握用指针类型描述、访问和处理二叉树的运算;熟练掌握二叉树的遍历算法;。

2、较高要求: 在遍历算法的基础上设计二叉树更复杂操作算法;认识哈夫曼树、哈夫曼编码的作用和意义;掌握树与森林的存储与便利。

二. 实验学时:课内实验学时:3学时课外实验学时:6学时三.实验题目1.以二叉链表为存储结构,实现二叉树的创建、遍历(实验类型:验证型)1)问题描述:在主程序中设计一个简单的菜单,分别调用相应的函数功能:1…建立树2…前序遍历树3…中序遍历树4…后序遍历树5…求二叉树的高度6…求二叉树的叶子节点7…非递归中序遍历树0…结束2)实验要求:在程序中定义下述函数,并实现要求的函数功能:CreateBinTree(BinTree &T): 按从键盘输入的前序序列,创建树Preorder(BinTree &T):前序遍历树(递归)Inorder(BinTree &T):中序(递归)遍历树Postorder(BinTree &T): 后序遍历树(递归)PostTreeDepth(BinTree &T):树的高度leaf(BinTree &T):树的叶子节点InorderN(BinTree &T):中序(非递归)遍历树3)数据结构二叉链表存储数据类型定义typedef struct node{TElemType data;struct node *lchild,*rchild;}BinTNode;元素类型:int CreateBinTree(BinTree &T);void Preorder(BinTree &T);void Inorder(BinTree &T);void Postorder(BinTree &T);void InorderN(BinTree &T);int PostTreeDepth(BinTree &T);int leaf(BinTree &T);2、编写算法实现二叉树的非递归中序遍历和求二叉树高度。

二叉树的建立与先序,中序,后序,层次遍历,图的深度优先搜索和广度优先搜索 实验报告

二叉树的建立与先序,中序,后序,层次遍历,图的深度优先搜索和广度优先搜索 实验报告

树和图的遍历实验报告2011-4-9实验题目:树和图的遍历实验目的:1.实现二叉树的建立与先序,中序,后序,层次遍历2.选择建立图的类型;根据所选择的类型用邻接矩阵的存储结构构建图;对图进行深度优先搜索和广度优先搜索;实验内容:一、算法描述:(1)二叉树的建立要建立一棵树就要有根节点和两棵子树。

两棵子树的建立同样需要这样的过程。

建立二叉树的过程也是遍历树的过程,实验要求以前序遍历的方式输入数据,因此我们也应按前序遍历的顺序,动态申请存储空间的方式建立这棵树并返回根节点的指针。

BiTNode *CreateBiTree(BiTNode *T){char ch;if((ch=getchar())==' ') T=NULL;else if(ch!='\n'){if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(1);T->data=ch;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}return T;}(2)二叉树的遍历遍历作为二叉树所有操作的基础,因此我把它放在二叉树建立的前面。

前序遍历:即按照根节点,左子树,右子树的顺序访问。

具体操作:遇到节点,立即打印根节点的值,然后访问左子树,再访问右子树。

对左子树和右子树的访问也进行相同的操作。

void PreOrderTraverse(BiTree T){if(T){putchar(T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}同理,易得中序遍历,后序遍历的操作。

//中序遍历二叉树void InOrderTraverse(BiTree T){if(T){InOrderTraverse(T->lchild);putchar(T->data);InOrderTraverse(T->rchild);}}//后序遍历二叉树void PostOrderTraverse(BiTree T){if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);putchar(T->data);}}层次遍历:先访问的节点,其孩子节点也必然优先访问,这就用到了队列的思想。

二叉树的建立及其遍历实验报告

二叉树的建立及其遍历实验报告

数据结构实验报告———二叉树的建立及其遍历一、实验目的1、了解二叉树的建立的方法及其遍历的顺序,熟悉二叉树的三种遍历2、检验输入的数据是否可以构成一颗二叉树二、实验的描述和算法1、实验描述二叉树的建立首先要建立一个二叉链表的结构体,包含根节点和左右子树。

因为耳熟的每一个左右子树又是一颗二叉树,所以可以用递归的方法来建立其左右子树。

二叉树的遍历是一种把二叉树的每一个节点访问完并输出的过程,遍历时根结点与左右孩子的输出顺序构成了不同的遍历方法,这个过程需要按照不同的遍历的方法,先输出根结点还是先输出左右孩子,可以用选择语句实现。

2、算法#include <stdio.h>#include <stdlib.h>#define OVERFLOW 0#define OK 1#define ERROR 0typedef struct BiTNode {char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;BiTree CreateBiTree(BiTree T){scanf("%c",&e);if(e==' ') T=NULL;else {if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(OVERFLOW);T->data=e;T->lchild=CreateBiTree(T->lchild);T->rchild=CreateBiTree(T->rchild);}return T; }/************************前序遍历***********************/ char PreOrderTraverse(BiTree T,char (* Visit)(char e)){if(T){if(Visit(T->data))if(PreOrderTraverse(T->lchild,Visit))if(PreOrderTraverse(T->rchild,Visit)) return OK;return ERROR;}else return OK;}char Visit(char e){printf("%5c",e);return OK;}main(){printf("请输入一颗二叉树,按回车结束:\n");T=CreateBiTree(T);printf("先序遍历的结果:");PreOrderTraverse(T,Visit);}三、调试分析在调这个程序是并没有遇到很大的困难,就是在输入一颗二叉树时,遇到了一点麻烦。

实验四 二叉树运算与遍历实验报告

实验四    二叉树运算与遍历实验报告

实验四二叉树运算与遍历实验报告学号-姓名实验时间 2010 年05月24日诚信声明本实验及实验报告所写内容为本人所做,没有抄袭。

实验题目与实验目的题目一:二叉树的遍历运算。

基本要求:在二叉树的二叉链表存储结构基础上,实现二叉树的以下运算:(1)创建二叉树的二叉树链表表示;(2)实现二叉树的先序遍历运算,输出先序遍历运算序列;(3)实现二叉树的中序遍历运算,输出中序遍历运算序列;(4)实现二叉树的后续遍历运算,输出后续遍历运算序列。

实验过程中遇到的主要问题1.根结点忘记申请内存;2.没有添加if(ch=='.')T=NULL;这个作为条件来创造一棵二叉树;3.遍历时没有弄清楚顺序,搞混了先序和中序的顺序。

实验小结1.对结构体的进一步的掌握;2.对递归算法的进一步认识与运用;3.对二叉树的理解由思想到代码实现;4.代码实现思想就是我们应该把问题循环化。

数据结构(自定义数据类型)typedef struct BiTnode{int date;struct BiTnode *lchild, *rchild;}BiTnode,*Bitree; //二叉树链式存储定义主要算法(或算法说明)int createbitree(Bitree &T){char ch;scanf("%c",&ch);if(ch=='.')T=NULL; //条件的判定else{ if(!(T=(Bitree)malloc(sizeof(BiTnode)))) return -1;T->date=ch;createbitree(T->lchild);createbitree(T->rchild);}return 0;} //建立一棵二叉树int preordertraverse(Bitree T){if(T==NULL)return -1;printf("%c",T->date);preordertraverse(T->lchild);preordertraverse(T->rchild);} //先序遍历。

二叉树的遍历(先序遍历、中序遍历、后序遍历全)实验报告

二叉树的遍历(先序遍历、中序遍历、后序遍历全)实验报告

实验目的编写一个程序,实现二叉树的先序遍历,中序遍历,后序遍历。

实验内容编程序并上机调试运行。

编写一个程序,实现二叉树的先序遍历,中序遍历,后序遍历。

编写程序/***********二叉树的遍历**************/#include<stdio.h>#include<stdlib.h>typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;/*************************************************///按先序次序构建的二叉树链表void CreatBiTree(BiTree *T){char ch;if((ch=getchar())==' ')*T=NULL;else{*T=(BiTNode*)malloc(sizeof(BiTNode));if(!(*T))exit(1);(*T)->data=ch;CreatBiTree(&(*T)->lchild);CreatBiTree(&(*T)->rchild);}}/*************************************************/ //先序遍历--递归算法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);}}/*************************************************/ //main函数void main(){BiTree T;printf("请按先序次序输入二叉树中结点的值,空格字符表示空树:\n" );CreatBiTree(&T);printf("\n");printf("先序遍历为:\n");PreOrderTraverse(T);printf("\n\n");printf("中序遍历为:\n");InOrderTraverse(T);printf("\n\n");printf("后序遍历为:\n");PostOrderTraverse(T);printf("\n\n");getchar();}运行程序:结果分析:按先序输入的二叉树为ABC^^DE^G^^F^^^(^为空格)该二叉树画成树形为:其先序遍历为:ABCDEGF其中序遍历为:CBEGDFA其后序遍历为:CGEFDBA可以看出运行结果是正确的。

二叉树的遍历算法实验报告

二叉树的遍历算法实验报告

二叉树实验报告09信管石旭琳 20091004418一、实验目的:1、理解二叉树的遍历算法及应用2、理解哈夫曼树及其应用。

3、掌握哈夫曼编码思想。

二、实验内容:1、建立二叉树二叉链表2、实现二叉树递归遍历算法(中序、前序、后序)3、求二叉树高度4、求二叉树结点个数5、求二叉树叶子个数6、将序号为偶数的值赋给左子树三、主要程序:#include<stdio.h>#include<stdlib.h>typedef int ElemType;struct BiTNode{ElemType data;struct BiTNode *lch,*rch;}BiTNode,*BiTree;struct BiTNode *creat_bt1();struct BiTNode *creat_bt2();void preorder (struct BiTNode *t);void inorder (struct BiTNode *t);void postorder (struct BiTNode *t);void numbt (struct BiTNode *t);int n,n0,n1,n2;void main(){int k;printf("\n\n\n");printf("\n\n 1.建立二叉树方法1(借助一维数组建立)"); printf("\n\n 2.建立二叉树方法2(先序递归遍历建立)"); printf("\n\n 3.先序递归遍历二叉树");printf("\n\n 4.中序递归遍历二叉树");printf("\n\n 5.后序递归遍历二叉树");printf("\n\n 6.计算二叉树结点个数");printf("\n\n 7.结束程序运行");printf("\n==================================="); do{printf("\n请输入你要执行的操作(1,2,3,4,5,6,7)");scanf("%d",&k);printf("\n");switch(k){case 1:{printf("你选择的是操作1,现用方法1进行建立二叉树\n");BiTree=creat_bt1(); /* 调用性质5建立二叉树算法*/break;}case 2:{printf("你选择的是操作2,现用方法2进行建立二叉树\n");BiTree=creat_bt2(); /* 调用递归建立二叉树算法*/break;}case 3:{printf("你选择的是操作3,现进行先序递归遍历二叉树\n结果为:");preorder(BiTree);break;}case 4:{printf("你选择的是操作4,现进行中序递归遍历二叉树\n结果为:");inorder(BiTree);break;}case 5:{printf("你选择的是操作5,现进行后序递归遍历二叉树\n结果为:");postorder(BiTree);break;}case 6:{ n=0,n0=0,n1=0,n2=0; /*全局变量置0 */printf("你选择的是操作6,现进行计算二叉树结点个数\n结果为:");numbt(BiTree);printf("\n 二叉树结点总数是:%d",n);printf("\n 二叉树叶子结点数是:%d",n0);printf("\n 度为1的结点数是:%d",n1);printf("\n 度为2的结点数是:%d",n2);break;}case 7:{printf("你选择的是操作8,将结束本程序运行,谢谢你的使用,再见!\n");break;}}}while(k>=1&&k<7);}struct BiTNode *creat_bt1(){struct BiTNode *v[50],*p,*t;int i,j;ElemType e; /*输入结点的序号i、结点的数据e */printf("\n i,data=");scanf("%d,%d",&i,&e);while(i!=0&&e!=0){p=(struct BiTNode *)malloc(sizeof(struct BiTNode));p->data=e;p->lch=NULL;p->rch=NULL;v[i]=p;if (i==1) /*序号为1的结点是根*/t=p;else{j=(i+1)/2;if(i%2==0) /*序号为偶数,做左孩子*/v[j]->lch=p;elsev[j]->rch=p;}printf("\n i,data=");scanf("%d,%d",&i,&e);}return t;}struct BiTNode *creat_bt2(){struct BiTNode *t;int e;printf("\n data=");scanf("%d",&e);if(e==0) t=NULL; /*对于0值,不分配新结点*/else{t=(struct BiTNode *)malloc(sizeof(struct BiTNode));t->data=e;t->lch=creat_bt2(); /*左孩子获得新指针值*/t->rch=creat_bt2();}return (t);}void preorder (struct BiTNode *t){if(t){printf("%d ",t->data);preorder(t->lch);preorder(t->rch);}}void inorder (struct BiTNode *t){if(t){inorder(t->lch);printf("%d ",t->data);inorder(t->rch);}}void postorder(struct BiTNode *t){if(t){postorder(t->lch);postorder(t->rch);printf("%d ",t->data);}}void numbt(struct BiTNode *t){if(t){numbt(t->lch);{n++;if(t->lch==NULL&&t->rch==NULL)n0++;if((t->lch==NULL&&t->rch!=NULL)||(t->lch!=NULL&&t->rch==NUL L))n1++;if(t->lch!=NULL&&t->rch!=NULL)n2++;}numbt(t->rch);}}四、测试结果:五、小结:实操后还是会搞不清楚数据域及指针域的定义类型的不同。

二叉树的创建与遍历实验完整word版二叉树建立与遍历实验报告范文c语言编写

二叉树的创建与遍历实验完整word版二叉树建立与遍历实验报告范文c语言编写

二叉树的创建与遍历实验完整word版二叉树建立与遍历实验报告范文c语言编写级班年月日姓名学号_1.实验题目建立一棵二叉树,并对其进行遍历(先序、中序、后序),打印输出遍历结果。

2.需求分析本程序用VC编写,实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。

①输入的形式和输入值的范围:输入二叉树的先序,当其结点为空时,需要输入#。

(输入的先序仅含字母和#)②输出的形式:输出二叉树的先序、中序、后序。

③程序所能达到的功能:实现建立一棵二叉树的功能,并对其进行遍历(先序、中序、后序),并且打印输出遍历结果。

④测试数据:输入数据:输入ABC##DE#G##F###输出结果:二叉树的先序遍历为:ABCDEGF二叉树的中序遍历为:CBEGDFA二叉树的后序遍历为:CGEFDBA3.概要设计1)为了实现上述程序功能,需要定义二叉链表的抽象数据类型:typedeftructBinaryTreeNode{TElemTypedata;//二叉树结点中的数据域tructBinaryTreeNode某lchild,某rchild;//二叉树结点的左孩子和右孩子指针}BinaryTreeNode,某BiTree;第1页,共9页基本操作:A.voidCreateBinaryTree(BiTree&T)初始条件:无操作结果:建立了二叉树。

B.voidPreOrder(BiTreeT)初始条件:存在一棵二叉树操作结果:先序遍历二叉树,并且输出先序遍历的结果。

C.voidMidOrder(BiTreeT)初始条件:存在一棵二叉树操作结果:中序遍历二叉树,并且输出中序遍历的结果。

D.voidPotOrder(BiTreeT)初始条件:存在一棵二叉树操作结果:后序遍历二叉树,并且输出后序遍历的结果。

程序包含5个函数:1主函数main()○2先序建立二叉树voidCreateBinaryTree(BiTree&T)○3先序遍历二叉树,并且输出先序遍历的结果voidPreOrder(BiTreeT);○4中序遍历二叉树,并且输出中序遍历的结果voidMidOrder(BiTreeT);○5序遍历二叉树,并且输出后序遍历的结果voidPotOrder(BiTreeT);○各函数间关系如下:main()主函数CreateBinaryTreePreOrderMidOrderPotOrder2第页,共9页4.详细设计1)二叉链表的定义typedeftructBinaryTreeNode{定义一个树结点的数据域;定义一个该结点的左孩子指针和右孩子指针;}先序建立二叉树2)voidCreateBinaryTree(BiTree&T)//{;输入一个字符量NULL;if(输入字符=='#')T指针置值为ele{动态申请一个指向二叉树结构体的指针data;把输入字符赋值给新指针的数据域);成员新指针的lchild调用CreateBinaryTree();rchild成员调用CreateBinaryTree(新指针的}}3)voidPreOrder(BiTreeT)//先序遍历二叉树{{输出T的data域;先序遍历左子树;;先序遍历右子树}}页,共3第9页4)voidMidOrder(BiTreeT)//中序遍历二叉树{if(T指针不为NULL){中序遍历左子树;输出T的data域;;中序遍历右子树}}5)voidPotOrder(BiTreeT)//中序遍历二叉树{;后序遍历左子树;后序遍历右子树;data域T输出的}}.调试分析5,程序运行了一段时间没,&ch)中的%c写成%d%c在编写程序过程中,我将canf(””有结果,经过检查,发现了这个错误。

二叉树遍历的实习报告

二叉树遍历的实习报告

实习报告实习内容:二叉树遍历实习时间:2023实习单位:某高校计算机实验室一、实习目的本次实习的主要目的是通过实现二叉树的遍历,加深对二叉树数据结构的理解,掌握二叉树的常见操作,提高编程能力。

二、实习内容1. 理解二叉树的基本概念和性质,包括节点之间的关系、树的深度、高度等。

2. 掌握二叉树的存储结构,包括顺序存储和链式存储。

3. 实现二叉树的前序遍历、中序遍历和后序遍历。

4. 通过实际编程,验证二叉树遍历的正确性。

三、实习过程1. 二叉树的基本概念和性质:二叉树是一种非线性的数据结构,每个节点最多有两个子节点。

节点之间的关系包括父子关系、兄弟关系等。

树的深度是指从根节点到最远叶子节点的最长路径上的边数,高度是指从根节点到最远叶子节点的最长路径上的边数加1。

2. 二叉树的存储结构:二叉树可以用顺序存储结构或链式存储结构表示。

顺序存储结构使用数组来实现,每个节点存储在数组的一个位置中,节点之间的父子关系通过数组下标来表示。

链式存储结构使用链表来实现,每个节点包含数据域和两个指针域,分别指向左子节点和右子节点。

3. 二叉树的遍历:二叉树的遍历是指按照一定的顺序访问树中的所有节点。

常见的遍历方式有前序遍历、中序遍历和后序遍历。

前序遍历是指先访问根节点,然后递归遍历左子树,最后递归遍历右子树。

中序遍历是指先递归遍历左子树,然后访问根节点,最后递归遍历右子树。

后序遍历是指先递归遍历左子树,然后递归遍历右子树,最后访问根节点。

4. 编程实现:根据二叉树的存储结构和遍历方法,编写C语言程序实现二叉树的前序遍历、中序遍历和后序遍历。

程序中使用递归函数来实现遍历操作,通过建立链式存储结构,验证遍历的正确性。

四、实习心得通过本次实习,我对二叉树的数据结构有了更深入的了解,掌握了二叉树的存储方式和常见操作。

在实现二叉树遍历的过程中,我学会了如何使用递归函数解决问题,提高了编程能力。

同时,通过实际编程验证了二叉树遍历的正确性,增强了对算法理解的信心。

二叉树遍历实验报告

二叉树遍历实验报告

1.实验题目二叉树的建立与遍历[问题描述]建立一棵二叉树,并对其进行遍历(先序、中序、后序),打印输出遍历结果。

2.需求分析(1)输入的形式和输入值的范围:以字符形式按先序遍历输入(2)输出的形式:依次按递归先序、中序、后序遍历,非递归先序、中序、后序遍历结果输出(3) 程序所能达到的功能:从键盘接受输入(先序)进行遍历(先序、中序、后序),将遍历结果打印输。

(4) 测试数据:ABCффDEфGффFффф(其中ф表示空格字符)则输出结果为先序:ABCDEGF中序:CBEGDFA后序:CGBFDBA3.概要设计(1)struct btnode{char data; 数据struct btnode *Lchild;左子数指针struct btnode *Rchild; 右子数指针};struct btnode *createbt(struct btnode *bt )初始条件:空二叉树存在操作结果:先序建立二叉树void preOrder(struct btnode *bt)初始条件:二叉树存在递归先序遍历二叉树void preOrder1(struct btnode *bt)初始条件:二叉树存在操作结果:非递归先序遍历void midOrder(struct btnode *bt)初始条件:二叉树存在操作结果:递归中序遍历void midOrder1(struct btnode *bt)初始条件:二叉树存在操作结果:非递归中序遍历void postOrder(struct btnode *bt)初始条件:二叉树存在操作结果:递归后序遍历void postOrder1 (struct btnode *bt)初始条件:二叉树存在操作结果:非递归后序遍历void main() 主函数(2)void main() 主函数{*createbtpreOrderpreOrder1midOrdermidOrder1postOrderpostOrder1}4.详细设计struct btnode{char data;struct btnode *Lchild;struct btnode *Rchild;};struct btnode *createbt(struct btnode *bt ){ 输入结点数据c检查存储空间将c赋给结点参数p递归建立左子树递归建立右子树}void preOrder(struct btnode *bt){判断树是否为空输出根结点数data递归遍历左子树递归遍历右子树}void preOrder1(struct btnode *bt){定义栈,结点参数pWhile(栈或p是否为空){While(p!=null){输出根结点数data将根结点压栈遍历左子树}提取栈顶元素值栈顶元素出栈访问右子树}void midOrder(struct btnode *bt){判断树是否为空递归遍历左子树输出根结点数data递归遍历右子树}void midOrder1(struct btnode *bt){定义栈,结点参数pWhile(栈或p是否为空){While(p!=null){将根结点压栈遍历左子树}提取栈顶元素值输出根结点数data栈顶元素出栈访问右子树}void postOrder(struct btnode *bt){判断树是否为空递归遍历左子树递归遍历右子树输出根结点数data}void postOrder1 (struct btnode *bt){定义栈,结点参数p,prebt入栈While(栈或p是否为空){提取栈顶元素值if判断p是否为空或是pre的根结点输出根结点数data栈顶元素出栈栈顶元素p赋给pre记录else if右结点非空将右结点压栈if左结点将左结点压栈}}void main(){struct btnode *root=NULL;root=createbt(root);preOrder(root); midOrder(root); postOrder(root);preOrder1(root); midOrder1(root);postOrder1(root);}5.调试分析(1)先序建立二叉树时,虽用到递归建左右子树,但没有把他们赋值给根节点的左右指针,造成二叉树脱节。

二叉树的建立及遍历

二叉树的建立及遍历

数据结构实验五课程数据结构实验名称二叉树的建立与遍历第页专业班级学号某某实验日期:年月日评分一、实验目的1.学会实现二叉树结点结构和对二叉树的根本操作.2.掌握对二叉树每种操作的具体实现,学会利用递归方法编写对二叉树这种递归数据结构进展处理的算法.二、实验要求1.认真阅读和掌握和本实验相关的教材内容.2.编写完整程序完成下面的实验内容并上机运行.3.整理并上交实验报告.三、实验内容1.编写程序任意输入二叉树的结点个数和结点值,构造一棵二叉树,采用三种递归遍历算法<前序、中序、后序>对这棵二叉树进展遍历并计算出二叉树的高度.2 .编写程序生成下面所示的二叉树,并采用先序遍历的非递归算法对此二叉树进展遍历.四、实验步骤〔描述实验步骤与中间的结果或现象.在实验中做了什么事情,怎么做的,发生的现象和中间结果〕第一题#include "stdafx.h"#include"iostream.h"#include"stdlib.h"#include"stdio.h"#include<stack>using namespace std;#define NULL 0#define OK 1#define OVERFLOW -1typedef int Status;typedef struct node{char data;struct node *lchild;struct node *rchild;}*bitree;int k=0;int depth<bitree T>//树的高度{if<!T>return 0;else{int m=depth<T->lchild>;int n=depth<T->rchild>;return <m>n?m:n>+1;}}//先序,中序建树struct node *create<char *pre,char *ord,int n> {struct node * T;int m;T=NULL;if<n<=0>{return NULL;}else{m=0;T=new<struct node>;T->data=*pre;T->lchild=T->rchild=NULL;while<ord[m]!=*pre>m++;T->lchild=create<pre+1,ord,m>;T->rchild=create <pre+m+1,ord+m+1,n-m-1>; return T;}}//中序递归遍历void inorder<struct node *T>{if<!T>return;else{inorder<T->lchild >;cout<<T->data;inorder<T->rchild >;}}void inpre<struct node *T> {if<!T>return;else{cout<<T->data;inpre<T->lchild >;inpre<T->rchild >;}}void postorder<struct node *T> {if<!T>return;else{postorder <T->lchild >; postorder <T->rchild >;cout<<T->data;}}//先序非递归遍历void inpre1<struct node *T> {struct node *p;struct node *stack[20];int top=0;p=T;cout<<"非递归先序";while<p||top!=0>{while <p>{stack[top++]=p;cout<<p->data;p=p->lchild;}p=stack[--top];p=p->rchild ;}//中序非递归遍历void inorder1<struct node *T>{struct node *p;struct node *stack[20];int top=0;p=T;cout<<"非递归中序";while<p||top!=0>{while <p>{stack[top++]=p;p=p->lchild ;}p=stack[--top];cout<<p->data;p=p->rchild ;}}//主函数int main<>{bitree T;char pre[30],ord[30];int n,m;gets<pre>;gets<ord>;n=strlen<pre>;T=create<pre,ord,n>;inpre<T>;cout<<endl;postorder <T>;cout<<endl;inorder<T>;cout<<endl;inpre1<T>;cout<<endl;inorder1<T>;cout<<endl;m=depth<T>;cout<<"二叉树高度为:"<<m<<endl; return 0;第二题:#include "stdafx.h"#include"iostream.h"#include"stdlib.h"#include"stdio.h"#include<stack>using namespace std;#define NULL 0#define OK 1#define OVERFLOW -1typedef int Status;typedef struct node{char data;struct node *lchild;struct node *rchild;}*bitree;Status Create<bitree &T> //按先序次序输入二叉树中结点的值,!表示空树{char e;cout<<"输入树的元素:"<<endl;cin>>e;if<e=='!'> T=NULL;else{if<!<T=<node *>malloc<sizeof<node>>>>exit <OVERFLOW>;T->data=e;Create<T->lchild>;Create<T->rchild>;}return OK;}//先序非递归遍历void inpre<struct node *T>{struct node *p;struct node *stack[20];int top=0;p=T;cout<<"非递归先序";while<p||top!=0>{while <p>{stack[top++]=p;cout<<p->data;p=p->lchild;}p=stack[--top];p=p->rchild ;}}//主函数int main<>{bitree T;Create<T>;cout<<"输出的元素为:"<<endl;inpre<T>;return 0;}五实验结果第一题:输入先序为-+a*b%cd/ef输入后序为a+b*c%d-e/f得出结果:输入先序为abcd输入后序为bacd得出结果:第二题:六实验总结1 为什么头文件只用#include <iostream>using namespace std;不行,要把所写到的程序中所包含的头文件头写进去..于是就在想,反正以后不管这些头文件有没用到头写进去,省得一大堆麻烦.2 用先序建树的时候虽然只要输入一个字符串,但是要判断空树的情况.比拟麻烦.我个人觉得用先序与中序联合建树比拟简单.因为这样只要输入先序与中序就可以建树了.3 对于三种遍历的过程,要是用递归写的就根据书上所给出的遍历步骤做稍微的调整就好了.至于非递归的三种遍历,中序最为简单,用一个栈就可以完成了,思路是边进栈边收索左孩子,直到左孩子为空的时候才开始进展出栈输出再收索右孩子的操作.而非递归的先序遍历根本可以和中序一样,建立一个队列,在进栈的时候队列也进同样的元素,但是不与栈一起出栈.而是在最后进栈出栈完毕的时候,对队列进展出队列操作即可.4 二叉树对于进展表达式的前缀,中缀和后缀的表示有明显的优势,既方便,又容易理解.其先序,中序和后序分别对应这表达式的前缀,中缀和后缀.5 在建树与进展树的遍历的时候一定要理解其建树与遍历的整个过程.不然就会连为什么这样做都不知道.在遍历树的时候最常用到的就是栈的结构了〔非递归〕. 七:思考与提高1.如何计算二叉链表存储的二叉树中度数为1的结点数?答:int countleaf<bitree t,int count>{if<!<t->lchild> &&<t->rchild>count++;else if <<t->lchild>&&!<t->rchild>>count++;countleaf<t->lchild>;countleaf<t->rchild>;return count;}2.有—棵以二叉链表存储的二叉树,root指向根结点,p指向二叉树中任一结点,如何求从根结点到p所指结点之间的路径?答:void foundp<bitree t>{if<t==p>{Push<s, t->data>;Pop<s, t->data>;}foundp<t->lchild>;foundp<t->rchid>;}。

树和二叉树的建立和遍历-数据结构试验报告

树和二叉树的建立和遍历-数据结构试验报告

实验报告一:预习要求预习树和二叉树的存储结构、以递归为基本思想的相应遍历操作。

二:实验目的1、通过实验,掌握二叉树的建立与存储方法。

2、掌握二叉树的结构特性,以及各种存储结构的特点和适用范围。

3、掌握用指针类型描述、访问和处理二叉树的运算。

4、理解huffman编解码的算法三:实验内容以括号表示法输入一棵二叉树,编写算法建立二叉树的二叉链表结构;编写先序、中序、后序、层次遍历二叉树的算法;编写算法计算二叉树的结点数,叶子结点数,以及二叉树的深度。

四:实验原理及试验方法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,且存在Dr上的关系Hr包含于H;H={<root,x1>,<root,xr>,H1,Hr};(4) (D1,{H1})是一颗符合本定义的二叉树,称为根的左子树,(Dr,{Hr})是一颗符合本定义的二叉树,称为根的右子树。

基本操作P:CreateBiTree(&T,definition);初始条件:definition给出二叉树的定义。

操作结果:按definition构造二叉树T。

PreOrderTraverse(T);初始条件:二叉树T存在。

操作结果:先序遍历T 。

InOrderTraverse(T);初始条件:二叉树T存在。

操作结果:中序遍历T。

PostOrderTraverse(T);初始条件:二叉树T存在。

计算机软件实验报告(2)二叉树的建立与遍历

计算机软件实验报告(2)二叉树的建立与遍历

二叉树的建立与遍历一、实验目的进一步理解二叉树的逻辑结构和存储结构,掌握二叉树的建立与遍历算法。

二、实验内容1、用二叉链表创建二叉树①输入根结点值;②若左子树不空,则输入左子树,否则输入一个结束符;③若右子树不空,则输入右子树,否则输入一个结束符。

例如:FCA▲▲DB▲▲▲E▲GH▲▲P▲▲其中▲表示结束符2、遍历该二叉树(1) 先序遍历(DLR)若二叉树为空,则结束返回。

否则:①访问根结点;②先序遍历左子树;③先序遍历右子树。

(2) 中序遍历(LDR)若二叉树为空,则结束返回。

否则:①中序遍历左子树;②访问根结点;③中序遍历左子树。

(3) 后序遍历(LRD)若二叉树为空,则结束返回。

否则:①后序遍历左子树;②后序遍历左子树;③访问根结点。

实验思想:根据要求,输入二叉树各结点对应的编号和数值,建立一棵空树,存储相应数值并使左子树和右子树均为空树,根据计算,若编号为偶数则为左子树,若为奇数则为右子树。

最后遍历二叉树。

三、实验算法流程图与程序清单(一)二叉树的建立与先序遍历:1、算法流程图:2、实验清单:{char data;struct node1 *lchild,*rchild;}BTCHINALR;BTCHINALR * createbt( ){ BTCHINALR *q;struct node1 *s[30];int j,i,x;printf("建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开\n\n");printf("i,x = ");scanf("%d,%c",&i,&x);while(i != 0 && x != '$'){q = (BTCHINALR*)malloc(sizeof(BTCHINALR));q->data = x; q->lchild = NULL; q->rchild = NULL;s[i] = q;if(i != 1){j = i / 2;if(i % 2 == 0) s[j]->lchild = q;else s[j]->rchild = q;}printf("i,x = ");scanf("%d,%c",&i,&x);}return s[1];}void inorder(BTCHINALR *bt){if(bt != NULL){ inorder(bt->lchild);printf("%c ",bt->data);inorder(bt->rchild); }}main( ){ BTCHINALR *bt;char ch;int i;bt = createbt(); i = 1;while(i) {printf("\n先序遍历二叉树(递归按y键,): ");fflush(stdin);scanf("%c",&ch);if(ch == 'y') inorder(bt);printf("\n");}3、实验结果:建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开i,x = 1,li,x = 2,ki,x = 3,yi,x = 4,bi,x =5,si,x = 7,ci,x =11,vi,x = 15,ri,x = 0,$先序遍历二叉树(递归按y键,): yl k b s v y c r(二)、二叉树的建立与中序遍历:1、算法流程图:2、实验清单:{char data;struct node1 *lchild,*rchild;}BTCHINALR;BTCHINALR * createbt( ){ BTCHINALR *q;struct node1 *s[30];int j,i,x;printf("建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开\n\n");printf("i,x = ");scanf("%d,%c",&i,&x);while(i != 0 && x != '$'){q = (BTCHINALR*)malloc(sizeof(BTCHINALR));q->data = x; q->lchild = NULL; q->rchild = NULL;s[i] = q;if(i != 1){j = i / 2;if(i % 2 == 0) s[j]->lchild = q;else s[j]->rchild = q;}printf("i,x = ");scanf("%d,%c",&i,&x);}return s[1];}void inorder(BTCHINALR *bt){if(bt != NULL){ inorder(bt->lchild);printf("%c ",bt->data);inorder(bt->rchild); }}main( ){ BTCHINALR *bt;char ch;int i;bt = createbt(); i = 1;while(i) {printf("\n先序遍历二叉树(递归按y键,): ");fflush(stdin);scanf("%c",&ch);if(ch == 'y') inorder(bt);printf("\n");}3、实验结果:建立二叉树,输入结点对应的编号和值,编号和值之间用逗号隔开i,x = 1,li,x = 2,ki,x = 3,yi,x = 4,bi,x =5,si,x = 7,ci,x =11,vi,x = 15,ri,x = 0,$先序遍历二叉树(递归按y键,): yl k b s v y c r四、实验心得体会通过这次实验,锻炼了自己编程的能力,加深了自己对有关知识的理解。

(完整word版)《二叉树基本操作实验报告》

(完整word版)《二叉树基本操作实验报告》

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算学院:化学与材料科学学院专业班级:09级材料科学与工程系PB0920603姓名:李维谷学号:PB09206285邮箱:liwg@指导教师:贾伯琪实验时间:2010年10月17日一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。

问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。

由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。

处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。

算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。

输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。

对二叉树的一些运算结果以整型输出。

程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。

计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。

对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。

测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E 后,以广义表形式打印A (B (C,D (,F )))输 入 二:ABD □□EH □□□CF □G □□□ (以□表示空格),查找10,删除B 预测结果:先序遍历 ABDEHCFG中序遍历 DBHEAGFC 后序遍历 DHEBGFCA层次遍历 ABCDEFHG广义表打印 A (B(D,E(H)),C(F(,G)))叶子数 3 深度 4 宽度 3 非空子孙数 7 度为2的数目 2 度为1的数目3 查找10,失败。

实验四二叉树的建立及遍历

实验四二叉树的建立及遍历

实验四二叉树的建立与遍历【实验目的】掌握二叉树的定义、性质及存储方式,各种遍历算法。

【实验内容】1.采用二叉树链表作为存储构造,完成二叉树的建立,先序、中序和后序遍历的递归操作。

2.分别求所有叶子结点及结点总数的操作。

提示:设计一颗二叉树,输入完全二叉树的先序序列,用#代表虚结点〔空指针〕,如ABD###CE##F##,建立二叉树,求出先序、中序和后序遍历序列,求所有叶子及结点总数。

【程序源代码】#include<stdio.h>#include<stdlib.h>typedef char TElemType;typedef int Status;#define OK 1#define ERROR 0#define OVERFLOW 0typedef struct BiTNode {TElemType data;struct BiTNode *lchild, *rchild;}BiTNode , *BiTree;Status CreateBiTree(BiTree &BT);void CountLeaves(BiTree BT, int &count);int NodeCount(BiTree BT);void PreOrder(BiTree BT);void InOrder(BiTree BT);void PostOrder(BiTree BT);int main(){BiTree BT;int choice,cho;int logo = 1;printf("输入二叉树结点,以'#'为空指针\n"); CreateBiTree(BT);do{printf("\t 1:遍历二叉树\n");printf("\t 2:二叉树总结点数及叶子节点数\n"); printf("\t 3:退出程序\n ");printf("\t 输入选项: ");scanf("%2d",&choice);switch(choice){case 1:printf("1:先序遍历\n");printf("2:中序遍历\n");printf("3:后序遍历\n");scanf("%2d",&cho);switch(cho){case 1:PreOrder(BT);printf("\n");break;case 2:InOrder(BT);printf("\n");break;case 3:PostOrder( BT);printf("\n");break;default:printf("输入错误!\n");}break;case 2:int count;printf("总结点数为:%2d\n", NodeCount(BT)); CountLeaves(BT, count);printf("叶子结点数为:%2d\n", count);break;case 3 :e*it(0);break;default:printf("输入错误!\n");}} while(logo==1);return 0;}Status CreateBiTree(BiTree &BT){char ch;scanf("%c", &ch);if (ch == '#')BT = NULL;else{if (!(BT = (BiTree)malloc(sizeof(BiTNode))))e*it(OVERFLOW); BT->data = ch;CreateBiTree(BT->lchild);CreateBiTree(BT->rchild);}return OK;}void PreOrder(BiTree BT){if (BT != NULL){printf("%c ", BT->data);PreOrder(BT->lchild);PreOrder(BT->rchild);}}void InOrder(BiTree BT){if (BT != NULL){PreOrder(BT->lchild);printf("%c ", BT->data);PreOrder(BT->rchild);}}void PostOrder(BiTree BT){if (BT != NULL){PreOrder(BT->lchild);PreOrder(BT->rchild);printf("%c ", BT->data);}}void CountLeaves(BiTree BT,int &count) {if (BT){if (!BT->lchild && !BT->rchild)count++;CountLeaves(BT->lchild, count); CountLeaves(BT->rchild, count);}}int NodeCount(BiTree BT)//统计总结点数{if (BT == NULL)return 0;elsereturn (NodeCount(BT->lchild) + NodeCount(BT->rchild) + 1);}【运行结果分析】【实验收获与心得】在本次实验中,我对递归这个概念有了较为深刻的认识,对二叉树的建立、遍历也掌握得较为透彻,通过对书本上知识的运用,我对本章的局部知识的掌握程度得到了提高,通过将各个算法运用到编程中,也使我对原本不是太懂的算法的理解有了质的提高。

实验报告(二叉树)

实验报告(二叉树)

实验报告课程:数据结构(c语言)实验名称:二叉树的构建、基本操作和遍历系别:数字媒体技术实验日期:专业班级:媒体161 组别:无:学号:实验报告容验证性实验一、预习准备:实验目的:1、熟练掌握二叉树的结构特性,熟悉二叉树的各种存储结构的特点及适用围;2、熟练掌握二叉树的遍历方法及遍历算法;3、掌握建立哈夫曼树和哈夫曼编码的方法及带权路径长度的计算。

实验环境:Widows操作系统、VC6.0实验原理:1.定义:树:树(tree)是n(n>0)个结点的有限集T,其中,有且仅有一个特定的结点,称为树的根(root)。

当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1,T2,……Tm,其中每一个集合本身又是一棵树,称为根的子树(subtree)二叉树:二叉树是n(n>=0)个结点的有限集,它或为空树(n=0),或由一个根结点和两棵分别称为左子树和右子树的互不相交的二叉树构成。

哈夫曼树: 最优二叉树——赫夫曼树设有n个权值{w1,w2,……wn},构造一棵有n个叶子结点的二叉树,每个叶子的权值为wi,则wpl最小的二叉树叫Huffman树。

2. 特点:树:树中至少有一个结点——根树中各子树是互不相交的集合二叉树:每个结点至多有二棵子树(即不存在度大于2的结点)二叉树的子树有左、右之分,且其次序不能任意颠倒哈夫曼树:一棵有n个叶子结点的Huffman树有2n-1个结点采用顺序存储结构——动态分配数组存储3. 表示:遍历二叉树:先序遍历:先访问根结点,然后分别先序遍历左子树、右子树中序遍历:先中序遍历左子树,然后访问根结点,最后中序遍历右子树后序遍历:先后序遍历左、右子树,然后访问根结点 按层次遍历:从上到下、从左到右访问各结点 构造Huffman 树的方法——Huffman 算法(1) 根据给定的n 个权值{w1,w2,……wn},构造n 棵只有根 结点的二叉树,令起权值为wj ;(2) 在森林中选取两棵根结点权值最小的树作左右子树,构造一棵新的二叉树,置新二叉树根结点权值为其左右子树根结点权值之和;(3) 在森林中删除这两棵树,同时将新得到的二叉树加入森林中重复上述两步,直到只含一棵树为止,这棵树即哈夫曼树。

二叉树地创建与遍历实验报告

二叉树地创建与遍历实验报告

数据结构课内实验报告书一、实验题目:二叉树的创建与遍历二、实验目的:通过本次实验,熟练掌握二叉树的存储结构定义及其遍历算法的实现,学会利用栈编写非递归的遍历算法。

三、实验要求:建立一棵用二叉链表方式存储的二叉树,并对其进行遍历(先序、中序和后序),打印输出遍历结果。

要求:从键盘接受扩展先序序列,以二叉链表作为存储结构,建立二叉树,并将遍历结果打印输出。

采用递归和非递归两种方法实现。

四、设计与实现过程(1)存储结构定义typedefcharelemtype;typedefstructNode{elemtypedata;structNode*lchild;structNode*rchild;}BitNode;(2)算法描述Node*creat(Node*pre){chare;Node*head;e=getchar();if(e!=''){head=(Node*)malloc(sizeof(Node));head->data=e;head->Lchild=creat(head);if(head->Lchild==NULL){head->Lflag=1;head->Lchild=pre;}head->Rchild=creat(head);if(pre!=NULL&&pre->Rchild==NULL){ pre->Rflag=1;pre->Rchild=head;}returnhead;}else{returnNULL;}}Node*InPre(Node*root){Node*p;if(root->Lflag==1){p=root->Lchild;}else{for(p=root->Lchild;p->Rflag==0;p=p->Rchild); }returnp;}Node*InNext(Node*root){Node*p;if(root->Rflag==1){p=root->Rchild;}else{for(p=root->Rchild;p->Lflag==0;p=p->Lchild);}returnp;}Node*Infirst(Node*root){Node*p;p=root;if(!p){fprintf(stdout,"n");returnNULL;}while(p->Lflag==0){p=p->Lchild;}returnp;}voidTInOrder(Node*root){Node*p;p=Infirst(root);while(p!=NULL){fprintf(stdout,"%c",p->data);p=InNext(p);}printf("\n");}五、运行结果输入ABECD输出BEADC六、技巧与体会通过实验,锻炼了自己的能力,加深了自己对有关知识的理解。

二叉树的建立和遍历实验报告

二叉树的建立和遍历实验报告

二叉树的建立和遍历实验报告一、引言(100字)二叉树是一种常见的数据结构,它由根节点、左子树和右子树组成,具有递归性质。

本次实验的目的是了解二叉树的建立过程和遍历算法,以及熟悉二叉树的相关操作。

本实验采用C语言进行编写。

二、实验内容(200字)1.二叉树的建立:通过输入节点的值,逐个建立二叉树的节点,并通过指针连接起来。

2.二叉树的遍历:实现二叉树的三种常用遍历算法,即前序遍历、中序遍历和后序遍历。

三、实验过程(400字)1.二叉树的建立:首先,定义二叉树的节点结构,包含节点值和指向左右子树的指针;然后,通过递归的方式,依次输入节点的值,创建二叉树节点,建立好节点之间的连接。

2.二叉树的前序遍历:定义一个函数,实现前序遍历的递归算法,先输出当前节点的值,再递归遍历左子树和右子树。

3.二叉树的中序遍历:同样,定义一个函数,实现中序遍历的递归算法,先递归遍历左子树,再输出当前节点的值,最后递归遍历右子树。

4.二叉树的后序遍历:同样,定义一个函数,实现后序遍历的递归算法,先递归遍历左子树和右子树,再输出当前节点的值。

四、实验结果(300字)通过实验,我成功建立了一个二叉树,并实现了三种遍历算法。

对于建立二叉树来说,只要按照递归的思路,先输入根节点的值,再分别输入左子树和右子树的值,即可依次建立好节点之间的连接。

建立好二叉树后,即可进行遍历操作。

在进行遍历算法的实现时,我首先定义了一个函数来进行递归遍历操作。

在每一次递归调用中,我首先判断当前节点是否为空,若为空则直接返回;若不为空,则按照特定的顺序进行遍历操作。

在前序遍历中,我先输出当前节点的值,再递归遍历左子树和右子树;在中序遍历中,我先递归遍历左子树,再输出当前节点的值,最后递归遍历右子树;在后序遍历中,我先递归遍历左子树和右子树,再输出当前节点的值。

通过运行程序,我成功进行了二叉树的建立和遍历,并得到了正确的结果。

可以看到,通过不同的遍历顺序,可以获得不同的遍历结果,这也是二叉树遍历算法的特性所在。

数据结构二叉树遍历实验报告

数据结构二叉树遍历实验报告

问题一:二叉树遍历1.问题描述设输入该二叉树的前序序列为:ABC##DE#G##F##HI##J#K##〔#代表空子树〕请编程完成以下任务:⑴请根据此输入来建立该二叉树,并输出该二叉树的前序、中序和后序序列;⑵按层次遍历的方法来输出该二叉树按层次遍历的序列;⑶求该二叉树的高度。

2. 设计描述〔 1 〕二叉树是一种树形构造,遍历就是要让树中的所有节点被且仅被一次,即按一定规律罗列成一个线性队列。

二叉〔子〕树是一种递归定义的构造,包含三个局部:根结点〔 N〕、左子树〔 L〕、右子树〔 R〕。

根据这三个局部的次序对二叉树的遍历发展分类,总共有 6种遍历方案: NLR 、LNR 、LRN 、NRL 、RNL和 LNR 。

研究二叉树的遍历就是研究这 6种具体的遍历方案,显然根据简单的对称性,左子树和右子树的遍历可互换,即 NLR与 NRL 、LNR与 RNL 、LRN与 RLN ,分别相类似,于是只需研究 NLR 、LNR和 LRN 三种即可,分别称为先序遍历〞、中序遍历〞和后序遍历〞。

采用递归方式就可以容易的实现二叉树的遍历,算法简单且直观。

〔2〕此外,二叉树的层次遍历即按照二叉树的层次构造发展遍历,按照从上到下,同一层从左到右的次序各节点。

遍历算法可以利用队列来实现,开场时将整个树的根节点入队,然后每从队列中删除一个节点并输出该节点的值时,都将它的非空的摆布子树入队,当队列完毕时算法完毕。

〔3〕计算二叉树高度也是利用递归来实现:假设一颗二叉树为空,则它的深度为 0 ,否则深度等于摆布子树的最大深度加一。

3 .源程序1 #include <stdio.h>2 #include <stdlib.h>3 #include <malloc.h>4 #define ElemType char5 struct BTreeNode {6 ElemType data;7 struct BTreeNode* left;8 struct BTreeNode* right;9 };10 void CreateBTree(struct BTreeNode** T)11 {12 char ch;1314 if (ch == '#') *T = NULL;15 else {16 (*T) = malloc(sizeof(struct BTreeNode));17 (*T)->data = ch;18 CreateBTree(&((*T)->left));19 CreateBTree(&((*T)->right));20 }21 }22 void Preorder(struct BTreeNode* T)23 {24 if (T != NULL) {2526 Preorder(T->left);27 Preorder(T->right);28 }29 }30 void Inorder(struct BTreeNode* T)31 {32 if (T != NULL) {33 Inorder(T->left);3435 Inorder(T->right);36 }37 }38 void Postorder(struct BTreeNode* T)39 {40 if (T != NULL) {41 Postorder(T->left);42 Postorder(T->right);4344 }45 }46 void Levelorder(struct BTreeNode* BT)47 {48 struct BTreeNode* p;49 struct BTreeNode* q[30];50 int front=0,rear=0;51 if(BT!=NULL) {52 rear=(rear+1)% 30;53 q[rear]=BT;54 }55 while(front!=rear) {56 front=(front+1)% 30;57 p=q[front];5859 if(p->left!=NULL) {60 rear=(rear+1)% 30;61 q[rear]=p->left;62 }63 if(p->right!=NULL) {64 rear=(rear+1)% 30;65 q[rear]=p->right;66 }67 }68 }69 int getHeight(struct BTreeNode* T)70 {71 int lh,rh;72 if (T == NULL) return 0;73 lh = getHeight(T->left);74 rh = getHeight(T->right);7576 }77 void main(void)78 {79 struct BTreeNode* T;80 CreateBTree(&T);81 前序序列:82 Preorder(T);8384 中序序列:85 Inorder(T);-4.运行结果问题二:哈夫曼编码、译码系统1. 问题描述 对一个ASCII 编码的文本文件中的字符发展哈夫曼编码,生成编码文件; 反过来,可将编码文件译码复原为一个文本文件〔选做〕 。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

二叉树的建立和遍历的实验报告篇一:二叉树的建立及遍历实验报告实验三:二叉树的建立及遍历【实验目的】(1)掌握利用先序序列建立二叉树的二叉链表的过程。

(2)掌握二叉树的先序、中序和后序遍历算法。

【实验内容】1. 编写程序,实现二叉树的建立,并实现先序、中序和后序遍历。

如:输入先序序列abc###de###,则建立如下图所示的二叉树。

并显示其先序序列为:abcde中序序列为:cbaed后序序列为:cbeda【实验步骤】1.打开VC++。

2.建立工程:点File->New,选Project标签,在列表中选Win32 Console Application,再在右边的框里为工程起好名字,选好路径,点OK->finish。

至此工程建立完毕。

3.创建源文件或头文件:点File->New,选File标签,在列表里选C++ Source File。

给文件起好名字,选好路径,点OK。

至此一个源文件就被添加到了你刚创建的工程之中。

4.写好代码5.编译->链接->调试#include#include#define OK 1#define OVERFLOW -2typedef int Status;typedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild, *rchild;}BiTNode,*BiTree;Status CreateBiTree(BiTree &T){TElemType ch;scanf("%c",&ch);if (ch=='#')T= NULL;else{if (!(T = (BiTNode *)malloc(sizeof(BiTNode))))return OVERFLOW;T->data = ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); }return OK;} // CreateBiTreevoid PreOrder(BiTree T) {if(T){printf("%c",T->data); PreOrder(T->lchild); PreOrder(T->rchild);}}void InOrder(BiTree T) {if(T){InOrder(T->lchild);printf("%c",T->data);InOrder(T->rchild);}}void PostOrder(BiTree T){if(T){PostOrder(T->lchild); PostOrder(T->rchild);printf("%c",T->data);}}void main(){BiTree T;CreateBiTree(T);printf("\n先序遍历序列:"); PreOrder(T);printf("\n中序遍历序列:"); InOrder(T);printf("\n后序遍历序列:"); PostOrder(T);}【实验心得】这次实验主要是通过先序序列建立二叉树,和二叉树的先序、中序、后续遍历算法。

通过这次实验,我巩固了二叉树这部分知识,从中体会理论知识的重要性。

在做实验之前,要充分的理解本次实验的理论依据,这样才能达到事半功倍的效果。

如果在没有真正理解实验原理之盲目的开始实验,只会浪费时间和精力。

例如进行二叉树的遍历的时候,要先理解各种遍历的特点。

先序遍历是先遍历根节点,再依次先序遍历左右子树。

中序遍历是先中序遍历左子树,再访问根节点,最后中序遍历右子树。

而后序遍历则是先依次后续遍历左右子树,再访问根节点。

掌握了这些,在实验中我们就可以融会贯通,举一反三。

所以,这次实验让我懂得了理论知识的重要性,只有领悟了最基本的知识,在实验过程中我们才能够独立的思考,大胆的推断,不断的创新,进而提高动手能力。

篇二:C++二叉树的创建与遍历实验报告二叉树的创建与遍历一、实验目的1.学会实现二叉树结点结构和对二叉树的基本操作。

2.掌握对二叉树每种操作的具体实现,学会利用递归和非递归方法编写对二叉树这种递归数据结构进行处理的算法。

二、实验要求1.认真阅读和掌握和本实验相关的教材内容。

2.编写完整程序完成下面的实验内容并上机运行。

3.整理并上交实验报告。

三、实验内容1.编写程序任意输入二叉树的结点个数和结点值,构造一棵二叉树,采用三种递归和非递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历。

四、实验步骤源程序代码1#include#includeusing namespace std;templatestruct BinTreeNode//二叉树结点类定义{T data; //数据域BinTreeNode *leftChild,*rightChild; //左子女、右子女域BinTreeNode(T x=T(),BinTreeNode* l=NULL,BinTreeNode* r = NULL ):data(x),leftChild(l),rightChild(r){} //可选择参数的默认构造函数 };//------------------------------------------------------------------------- templatevoid PreOrder_2(BinTreeNode *p)//非递归前序遍历{stack * > S;} while(p!=NULL || !S.empty()) {} } p=S.top();S.pop();p = p->rightChild; //遍历指针进到右子女结点 while(p!=NULL) {coutdata; //访问根结点} if(!S.empty()) //栈不空时退栈{ S.push(p); p=p->leftChild;//遍历指针进到左子女结点//---------------------------------------------------------------- templatevoid InOrder_2(BinTreeNode *p)//非递归中序遍历{}stack* > S; do { } while(p !=NULL || !S.empty()); while(p!=NULL) //遍历指针未到最左下的结点,不空 {} if(!S.empty()) //栈不空时退栈 { } p=S.top(); S.pop();coutdata; p=p->rightChild;S.push(p); p=p->leftChild;//------------------------------------------------------------------ templatevoid PostOrder_2(BinTreeNode *p) //非递归后序遍历{}templatevoid InOrder_1(BinTreeNode * subTree){//递归函数:中序次序遍历以subTree为根的子树。

} if(subTree !=NULL)//NULL是递归终止条件 { } coutdata;//访问根结点InOrder_1(subTree->rightChild); //中序遍历根的右子树 InOrder_1(subTree->leftChild); //中序遍历根的左子树 stack * > S; stack tag;//定义一个新的栈用来保存tag域判别根结点的左右子树是否均遍历过 while(p != NULL || !S.empty())//左子树经过结点加L进栈{ } while(p!=NULL) {} while( !S.empty() && tag.top()==1) { } if( !S.empty()) { } else break; tag.pop(); tag.push(1);//遍历右子树前的现场保护,修改栈顶tag为,遍历右子树p=S.top(); // 取栈顶保存的指针p=p->rightChild; p=S.top(); S.pop(); tag.pop(); coutdata; //最后访问根结点。

S.push(p); //首先将t和tag为入栈,遍历左子树p=p->leftChild; tag.push(0);//遍历左子树前的现场保护templatevoid PreOrder_1(BinTreeNode * subTree){//递归函数:前序遍历以subTree为根的二叉树。

}templatevoid PostOrder_1(BinTreeNode * subTree){//递归函数:后序次序遍历以subTree为根的子树。

}//-------------------------------------------------------------------------- templatevoid CreateBinTree(BinTreeNode * & subTree){//递归方式建立二叉树if(item !=-1) {} else subTree = NULL; //封闭指向空子树的指针subTree = new BinTreeNode(); if(subTree == NULL) {} CreateBinTree(subTree->leftChild); //递归建立左子树CreateBinTree(subTree->rightChild); //递归建立右子树cerr>item; } coutdata; //访问根结点if(subTree !=NULL)//NULL是递归终止条件{PostOrder_1(subTree->leftChild); //后序遍历根的左子树 PostOrder_1(subTree->rightChild); //后序遍历根的右子树coutdata;//访问根结点} PreOrder_1(subTree->leftChild); //前序遍历根的左子树PreOrder_1(subTree->rightChild);//前序遍历根的右子树 if(subTree !=NULL)//递归结束条件 { subTree->data = item;}int main(){BinTreeNode * Tree = NULL;cout cout } cout篇三:二叉树的存储与遍历实现实验报告数据结构实验报告学院班级学号姓名实验五二叉树的存储与遍历实现实验报告。

相关文档
最新文档