数据结构实验二 树的应用

合集下载

数据结构平衡二叉树的操作演示

数据结构平衡二叉树的操作演示

平衡二叉树操作的演示1.需求分析本程序是利用平衡二叉树,实现动态查找表的基本功能:创建表,查找、插入、删除。

具体功能:(1)初始,平衡二叉树为空树,操作界面给出创建、查找、插入、删除、合并、分裂六种操作供选择。

每种操作均提示输入关键字。

每次插入或删除一个结点后,更新平衡二叉树的显示。

(2)平衡二叉树的显示采用凹入表现形式。

(3)合并两棵平衡二叉树。

(4)把一棵二叉树分裂为两棵平衡二叉树,使得在一棵树中的所有关键字都小于或等于x,另一棵树中的任一关键字都大于x。

如下图:2.概要设计平衡二叉树是在构造二叉排序树的过程中,每当插入一个新结点时,首先检查是否因插入新结点而破坏了二叉排序树的平衡性,若是则找出其中的最小不平衡子树,在保持二叉排序树特性的前提下,调整最小不平衡子树中各结点之间的链接关系,进行相应的旋转,使之成为新的平衡子树。

具体步骤:(1)每当插入一个新结点,从该结点开始向上计算各结点的平衡因子,即计算该结点的祖先结点的平衡因子,若该结点的祖先结点的平衡因子的绝对值不超过1,则平衡二叉树没有失去平衡,继续插入结点;(2)若插入结点的某祖先结点的平衡因子的绝对值大于1,则找出其中最小不平衡子树的根结点;(3)判断新插入的结点与最小不平衡子树的根结点个关系,确定是那种类型的调整;(4)如果是LL型或RR型,只需应用扁担原理旋转一次,在旋转过程中,如果出现冲突,应用旋转优先原则调整冲突;如果是LR型或RL型,则需应用扁担原理旋转两次,第一次最小不平衡子树的根结点先不动,调整插入结点所在子树,第二次再调整最小不平衡子树,在旋转过程中,如果出现冲突,应用旋转优先原则调整冲突;(5)计算调整后的平衡二叉树中各结点的平衡因子,检验是否因为旋转而破坏其他结点的平衡因子,以及调整后平衡二叉树中是否存在平衡因子大于1的结点。

流程图3.详细设计二叉树类型定义:typedef int Status;typedef int ElemType;typedef struct BSTNode{ElemType data;int bf;struct BSTNode *lchild ,*rchild;} BSTNode,* BSTree;Status SearchBST(BSTree T,ElemType e)//查找void R_Rotate(BSTree &p)//右旋void L_Rotate(BSTree &p)//左旋void LeftBalance(BSTree &T)//插入平衡调整void RightBalance(BSTree &T)//插入平衡调整Status InsertAVL(BSTree &T,ElemType e,int &taller)//插入void DELeftBalance(BSTree &T)//删除平衡调整void DERightBalance(BSTree &T)//删除平衡调整Status Delete(BSTree &T,int &shorter)//删除操作Status DeleteAVL(BSTree &T,ElemType e,int &shorter)//删除操作void merge(BSTree &T1,BSTree &T2)//合并操作void splitBSTree(BSTree T,ElemType e,BSTree &T1,BSTree &T2)//分裂操作void PrintBSTree(BSTree &T,int lev)//凹入表显示附录源代码:#include<stdio.h>#include<stdlib.h>//#define TRUE 1//#define FALSE 0//#define OK 1//#define ERROR 0#define LH +1#define EH 0#define RH -1//二叉类型树的类型定义typedef int Status;typedef int ElemType;typedef struct BSTNode{ElemType data;int bf;//结点的平衡因子struct BSTNode *lchild ,*rchild;//左、右孩子指针} BSTNode,* BSTree;/*查找算法*/Status SearchBST(BSTree T,ElemType e){if(!T){return 0; //查找失败}else if(e == T->data ){return 1; //查找成功}else if (e < T->data){return SearchBST(T->lchild,e);}else{return SearchBST(T->rchild,e);}}//右旋void R_Rotate(BSTree &p){BSTree lc; //处理之前的左子树根结点lc = p->lchild; //lc指向的*p的左子树根结点p->lchild = lc->rchild; //lc的右子树挂接为*P的左子树lc->rchild = p;p = lc; //p指向新的根结点}//左旋void L_Rotate(BSTree &p){BSTree rc;rc = p->rchild; //rc指向的*p的右子树根结点p->rchild = rc->lchild; //rc的左子树挂接为*p的右子树rc->lchild = p;p = rc; //p指向新的根结点}//对以指针T所指结点为根结点的二叉树作左平衡旋转处理,//本算法结束时指针T指向新的根结点void LeftBalance(BSTree &T){BSTree lc,rd;lc=T->lchild;//lc指向*T的左子树根结点switch(lc->bf){ //检查*T的左子树的平衡度,并做相应的平衡处理case LH: //新结点插入在*T的左孩子的左子树,要做单右旋处理T->bf = lc->bf=EH;R_Rotate(T);break;case RH: //新结点插入在*T的左孩子的右子树上,做双旋处理rd=lc->rchild; //rd指向*T的左孩子的右子树根switch(rd->bf){ //修改*T及其左孩子的平衡因子case LH: T->bf=RH; lc->bf=EH;break;case EH: T->bf=lc->bf=EH;break;case RH: T->bf=EH; lc->bf=LH;break;}rd->bf=EH;L_Rotate(T->lchild); //对*T的左子树作左旋平衡处理R_Rotate(T); //对*T作右旋平衡处理}}//右平衡旋转处理void RightBalance(BSTree &T){BSTree rc,ld;rc=T->rchild;switch(rc->bf){case RH:T->bf= rc->bf=EH;L_Rotate(T);break;case LH:ld=rc->lchild;switch(ld->bf){case LH: T->bf=RH; rc->bf=EH;break;case EH: T->bf=rc->bf=EH;break;case RH: T->bf = EH; rc->bf=LH;break;}ld->bf=EH;R_Rotate(T->rchild);L_Rotate(T);}}//插入结点Status InsertAVL(BSTree &T,ElemType e,int &taller){//taller反应T长高与否if(!T){//插入新结点,树长高,置taller为trueT= (BSTree) malloc (sizeof(BSTNode));T->data = e;T->lchild = T->rchild = NULL;T->bf = EH;taller = 1;}else{if(e == T->data){taller = 0;return 0;}if(e < T->data){if(!InsertAVL(T->lchild,e,taller))//未插入return 0;if(taller)//已插入到*T的左子树中且左子树长高switch(T->bf){//检查*T的平衡度,作相应的平衡处理case LH:LeftBalance(T);taller = 0;break;case EH:T->bf = LH;taller = 1;break;case RH:T->bf = EH;taller = 0;break;}}else{if (!InsertAVL(T->rchild,e,taller)){return 0;}if(taller)//插入到*T的右子树且右子树增高switch(T->bf){//检查*T的平衡度case LH:T->bf = EH;taller = 0;break;case EH:T->bf = RH;taller = 1;break;case RH:RightBalance(T);taller = 0;break;}}}return 1;}void DELeftBalance(BSTree &T){//删除平衡调整BSTree lc,rd;lc=T->lchild;switch(lc->bf){case LH:T->bf = EH;//lc->bf= EH;R_Rotate(T);break;case EH:T->bf = EH;lc->bf= EH;R_Rotate(T);break;case RH:rd=lc->rchild;switch(rd->bf){case LH: T->bf=RH; lc->bf=EH;break;case EH: T->bf=lc->bf=EH;break;case RH: T->bf=EH; lc->bf=LH;break;}rd->bf=EH;L_Rotate(T->lchild);R_Rotate(T);}}void DERightBalance(BSTree &T) //删除平衡调整{BSTree rc,ld;rc=T->rchild;switch(rc->bf){case RH:T->bf= EH;//rc->bf= EH;L_Rotate(T);break;case EH:T->bf= EH;//rc->bf= EH;L_Rotate(T);break;case LH:ld=rc->lchild;switch(ld->bf){case LH: T->bf=RH; rc->bf=EH;break;case EH: T->bf=rc->bf=EH;break;case RH: T->bf = EH; rc->bf=LH;break;}ld->bf=EH;R_Rotate(T->rchild);L_Rotate(T);}}void SDelete(BSTree &T,BSTree &q,BSTree &s,int &shorter){if(s->rchild){SDelete(T,s,s->rchild,shorter);if(shorter)switch(s->bf){case EH:s->bf = LH;shorter = 0;break;case RH:s->bf = EH;shorter = 1;break;case LH:DELeftBalance(s);shorter = 0;break;}return;}T->data = s->data;if(q != T)q->rchild = s->lchild;elseq->lchild = s->lchild;shorter = 1;}//删除结点Status Delete(BSTree &T,int &shorter){ BSTree q;if(!T->rchild){q = T;T = T->lchild;free(q);shorter = 1;}else if(!T->lchild){q = T;T= T->rchild;free(q);shorter = 1;}else{SDelete(T,T,T->lchild,shorter);if(shorter)switch(T->bf){case EH:T->bf = RH;shorter = 0;break;case LH:T->bf = EH;shorter = 1;break;case RH:DERightBalance(T);shorter = 0;break;}}return 1;}Status DeleteAVL(BSTree &T,ElemType e,int &shorter){ int sign = 0;if (!T){return sign;}else{if(e == T->data){sign = Delete(T,shorter);return sign;}else if(e < T->data){sign = DeleteAVL(T->lchild,e,shorter);if(shorter)switch(T->bf){case EH:T->bf = RH;shorter = 0;break;case LH:T->bf = EH;shorter = 1;break;case RH:DERightBalance(T);shorter = 0;break;}return sign;}else{sign = DeleteAVL(T->rchild,e,shorter);if(shorter)switch(T->bf){case EH:T->bf = LH;shorter = 0;break;case RH:T->bf = EH;break;case LH:DELeftBalance(T);shorter = 0;break;}return sign;}}}//合并void merge(BSTree &T1,BSTree &T2){int taller = 0;if(!T2)return;merge(T1,T2->lchild);InsertAVL(T1,T2->data,taller);merge(T1,T2->rchild);}//分裂void split(BSTree T,ElemType e,BSTree &T1,BSTree &T2){ int taller = 0;if(!T)return;split(T->lchild,e,T1,T2);if(T->data > e)InsertAVL(T2,T->data,taller);elseInsertAVL(T1,T->data,taller);split(T->rchild,e,T1,T2);}//分裂void splitBSTree(BSTree T,ElemType e,BSTree &T1,BSTree &T2){ BSTree t1 = NULL,t2 = NULL;split(T,e,t1,t2);T1 = t1;T2 = t2;return;}//构建void CreatBSTree(BSTree &T){int num,i,e,taller = 0;printf("输入结点个数:");scanf("%d",&num);printf("请顺序输入结点值\n");for(i = 0 ;i < num;i++){printf("第%d个结点的值",i+1);scanf("%d",&e);InsertAVL(T,e,taller) ;}printf("构建成功,输入任意字符返回\n");getchar();getchar();}//凹入表形式显示方法void PrintBSTree(BSTree &T,int lev){int i;if(T->rchild)PrintBSTree(T->rchild,lev+1);for(i = 0;i < lev;i++)printf(" ");printf("%d\n",T->data);if(T->lchild)PrintBSTree(T->lchild,lev+1);void Start(BSTree &T1,BSTree &T2){int cho,taller,e,k;taller = 0;k = 0;while(1){system("cls");printf(" 平衡二叉树操作的演示 \n\n");printf("********************************\n");printf(" 平衡二叉树显示区 \n");printf("T1树\n");if(!T1 )printf("\n 当前为空树\n");else{PrintBSTree(T1,1);}printf("T2树\n");if(!T2 )printf("\n 当前为空树\n");elsePrintBSTree(T2,1);printf("\n********************************************************************* *********\n");printf("T1操作:1.创建 2.插入 3.查找 4.删除 10.分裂\n");printf("T2操作:5.创建 6.插入 7.查找 8.删除 11.分裂\n");printf(" 9.合并 T1,T2 0.退出\n");printf("*********************************************************************** *******\n");printf("输入你要进行的操作:");scanf("%d",&cho);switch(cho){case 1:CreatBSTree(T1);break;case 2:printf("请输入要插入关键字的值");scanf("%d",&e);InsertAVL(T1,e,taller) ;break;case 3:printf("请输入要查找关键字的值");scanf("%d",&e);if(SearchBST(T1,e))printf("查找成功!\n");elseprintf("查找失败!\n");printf("按任意键返回87"); getchar();getchar();break;case 4:printf("请输入要删除关键字的值"); scanf("%d",&e);if(DeleteAVL(T1,e,k))printf("删除成功!\n");elseprintf("删除失败!\n");printf("按任意键返回");getchar();getchar();break;case 5:CreatBSTree(T2);break;case 6:printf("请输入要插入关键字的值"); scanf("%d",&e);InsertAVL(T2,e,taller) ;break;case 7:printf("请输入要查找关键字的值"); scanf("%d",&e);if(SearchBST(T2,e))printf("查找成功!\n");elseprintf("查找失败!\n");printf("按任意键返回");getchar();getchar();break;case 8:printf("请输入要删除关键字的值"); scanf("%d",&e);if(DeleteAVL(T2,e,k))printf("删除成功!\n");elseprintf("删除失败!\n");printf("按任意键返回");getchar();getchar();break;case 9:merge(T1,T2);T2 = NULL;printf("合并成功,按任意键返回"); getchar();getchar();break;case 10:printf("请输入要中间值字的值"); scanf("%d",&e);splitBSTree(T1,e,T1,T2) ;printf("分裂成功,按任意键返回"); getchar();getchar();break;case 11:printf("请输入要中间值字的值"); scanf("%d",&e);splitBSTree(T2,e,T1,T2) ;printf("分裂成功,按任意键返回"); getchar();getchar();break;case 0:system("cls");exit(0);}}}main(){BSTree T1 = NULL;BSTree T2 = NULL;Start(T1,T2);}。

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

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

实验报告一,实验目的:·掌握二叉树的链式存储结构;·掌握构造二叉树的方法;·加深对二叉树的中序遍历的理解;二,实验方法:·用递归调用算法中序遍历二叉树。

三,实验步骤:·通过链式存储建立一颗二叉树。

·设计一个算法实现中序遍历二叉树。

四,具体实验步骤:#include<stdio.h>#include<stdlib.h>#define LEFT 0#define RIGHT 1#define TRUE 1#define FALSE 0typedef struct _BTNODE{char c;struct _BTNODE *lchild;struct _BTNODE *rchild;}BTNODE,*PBTNODE;void PrintBTree(PBTNODE p,int depth);void ConstructBTree(PBTNODE p);void InorderTraverse(PBTNODE p);void main(){PBTNODE p;p=(PBTNODE)calloc(1,sizeof(BTNODE));printf("Input the data:");ConstructBTree(p);PrintBTree(p,0);printf("Now InorderTraverse:");InorderTraverse(p);printf("\nPress any key to continue...");getchar();}void PrintBTree(PBTNODE p,int depth){int i;if(p==NULL){return;}else{for(i=0;i<depth;i++){printf("--");}printf(">");printf("%c\n",p->c);PrintBTree(p->lchild,depth+1);PrintBTree(p->rchild,depth+1);}}void ConstructBTree(PBTNODE p){int side;char c;side=LEFT;while(TRUE){scanf("%c",&c);if(c=='\n'){//printf("EOF\n");return;}// printf("%d\n",c);switch(c){case '|':break;case')':return;case',':side=RIGHT;break;case'(':if(side==LEFT){if(p->lchild==NULL){p->lchild=(PBTNODE)calloc(1,sizeof(BTNODE));}ConstructBTree(p->lchild);}else{if(p->rchild==NULL){p->rchild=(PBTNODE)calloc(1,sizeof(BTNODE));}ConstructBTree(p->rchild);}break;default:if(side==LEFT){p->lchild=(PBTNODE)calloc(1,sizeof(BTNODE));p->lchild->c=c;}else{p->rchild=(PBTNODE)calloc(1,sizeof(BTNODE));p->rchild->c=c;}}}}void InorderTraverse(PBTNODE p){if(p==NULL){return;}else{InorderTraverse(p->lchild);printf("[%c] ",p->c);InorderTraverse(p->rchild);}return;}五,实验过程:·输出:Input the date;·输入:1(2(3,4),5(6,7));·输出:Now InorderTraverse:【3】【2】【4】【1】【6】【5】【7】;六,上机实验体会:·体会到熟练掌握各种程序算法的重要性;·通过上机练习,充分理解了链式建立二叉树的算法;·形象的了解二叉树的结构,能够熟练的进行先序,中序,后序遍历二叉树。

数据结构实验总结及心得体会

数据结构实验总结及心得体会

数据结构实验总结及心得体会引言数据结构作为计算机科学的基础课程,是理解和应用计算机编程的重要部分。

通过实验的形式,我们可以更加深入地理解不同数据结构的特点和应用场景。

本文将总结我在数据结构实验中的学习经验和心得体会。

实验一:线性表在线性表实验中,我学习了顺序表和链表两种基本的线性表结构。

顺序表使用数组来存储数据,具有随机访问的特点;链表使用指针来连接数据元素,具有插入和删除操作方便的特点。

通过这个实验,我深刻认识了线性表的存储结构和操作方法。

我遇到的难点是链表的插入和删除操作,因为涉及到指针的重新指向。

通过调试和分析代码,我逐渐理解了指针指向的含义和变化规律。

在实验结束后,我还进一步学习了循环链表和双向链表的特点和应用。

实验二:栈和队列栈和队列是两种常用的数据结构,可以用来解决很多实际问题。

在这个实验中,我学习了顺序栈、链式栈、顺序队列和链式队列四种基本实现方式。

实验中我遇到的最大困难是队列的循环队列实现,因为需要处理队列尾指针的位置变化。

我通过画图和调试发现了队列尾指针的变化规律,并在实验中成功实现了循环队列。

熟练掌握了栈和队列的操作方法后,我进一步学习了栈的应用场景,如表达式求值和括号匹配等。

队列的应用场景还有优先级队列和循环队列等。

实验三:串串是由零个或多个字符组成的有限序列,是实际应用中十分常见的数据类型。

在这个实验中,我学习了串的存储结构和常规操作。

实验中最具挑战性的部分是串的模式匹配。

模式匹配是在一个主串中查找一个子串的过程,可以使用暴力匹配、KMP 算法和BM算法等不同的匹配算法。

在实验中,我实现了KMP算法,并在实际应用中进行了测试。

从实验中我学到了使用前缀表和后缀表来提高模式匹配的效率。

同时,在应用中也了解到了串的搜索和替换等常见操作。

实验四:树和二叉树树是一种重要的非线性数据结构,应用广泛。

在这个实验中,我学习了树的基本概念、存储结构和遍历方式。

实验中最困难的部分是二叉树的遍历。

数据结构之二叉树(BinaryTree)

数据结构之二叉树(BinaryTree)

数据结构之⼆叉树(BinaryTree)⽬录导读 ⼆叉树是⼀种很常见的数据结构,但要注意的是,⼆叉树并不是树的特殊情况,⼆叉树与树是两种不⼀样的数据结构。

⽬录 ⼀、⼆叉树的定义 ⼆、⼆叉树为何不是特殊的树 三、⼆叉树的五种基本形态 四、⼆叉树相关术语 五、⼆叉树的主要性质(6个) 六、⼆叉树的存储结构(2种) 七、⼆叉树的遍历算法(4种) ⼋、⼆叉树的基本应⽤:⼆叉排序树、平衡⼆叉树、赫夫曼树及赫夫曼编码⼀、⼆叉树的定义 如果你知道树的定义(有限个结点组成的具有层次关系的集合),那么就很好理解⼆叉树了。

定义:⼆叉树是n(n≥0)个结点的有限集,⼆叉树是每个结点最多有两个⼦树的树结构,它由⼀个根结点及左⼦树和右⼦树组成。

(这⾥的左⼦树和右⼦树也是⼆叉树)。

值得注意的是,⼆叉树和“度⾄多为2的有序树”⼏乎⼀样,但,⼆叉树不是树的特殊情形。

具体分析如下⼆、⼆叉树为何不是特殊的树 1、⼆叉树与⽆序树不同 ⼆叉树的⼦树有左右之分,不能颠倒。

⽆序树的⼦树⽆左右之分。

2、⼆叉树与有序树也不同(关键) 当有序树有两个⼦树时,确实可以看做⼀颗⼆叉树,但当只有⼀个⼦树时,就没有了左右之分,如图所⽰:三、⼆叉树的五种基本状态四、⼆叉树相关术语是满⼆叉树;⽽国际定义为,不存在度为1的结点,即结点的度要么为2要么为0,这样的⼆叉树就称为满⼆叉树。

这两种概念完全不同,既然在国内,我们就默认第⼀种定义就好)。

完全⼆叉树:如果将⼀颗深度为K的⼆叉树按从上到下、从左到右的顺序进⾏编号,如果各结点的编号与深度为K的满⼆叉树相同位置的编号完全对应,那么这就是⼀颗完全⼆叉树。

如图所⽰:五、⼆叉树的主要性质 ⼆叉树的性质是基于它的结构⽽得来的,这些性质不必死记,使⽤到再查询或者⾃⼰根据⼆叉树结构进⾏推理即可。

性质1:⾮空⼆叉树的叶⼦结点数等于双分⽀结点数加1。

证明:设⼆叉树的叶⼦结点数为X,单分⽀结点数为Y,双分⽀结点数为Z。

数据结构-二叉排序树

数据结构-二叉排序树

二叉排序树操作一、设计步骤1)分析课程设计题目的要求2)写出详细设计说明3)编写程序代码,调试程序使其能正确运行4)设计完成的软件要便于操作和使用5)设计完成后提交课程设计报告(一)程序功能:1)创建二叉排序树2)输出二叉排序树3)在二叉排序树中插入新结点4)在二叉排序树中删除给定的值5)在二叉排序树中查找所给定的值(二)函数功能:1) struct BiTnode 定义二叉链表结点类型包含结点的信息2) class BT 二叉排序树类,以实现二叉排序树的相关操作3) InitBitree() 构造函数,使根节点指向空4) ~BT () 析构函数,释放结点空间5) void InsertBST(&t,key) 实现二叉排序树的插入功能6) int SearchBST(t,key) 实现二叉排序树的查找功能7) int DelBST(&t,key) 实现二叉排序树的删除功能8) void InorderBiTree (t) 实现二叉排序树的排序(输出功能)9) int main() 主函数,用来完成对二叉排序树类中各个函数的测试二、设计理论分析方法(一)二叉排序树定义首先,我们应该明确所谓二叉排序树是指满足下列条件的二叉树:(1)左子树上的所有结点值均小于根结点值;(2)右子数上的所有结点值均不小于根结点值;(3)左、右子数也满足上述两个条件。

根据对上述的理解和分析,我们就可以先创建出一个二叉链表结点的结构体类型(struct BiTNode)和一个二叉排序树类(class BT),以及类中的构造函数、析构函数和其他实现相关功能的函数。

(二)插入函数(void InsertBST(&t,key))首先定义一个与BiTNode<k> *BT同一类型的结点p,并为其申请空间,使p->data=key,p->lchild和p->rchild=NULL。

数据结构-二叉树的存储结构和遍历

数据结构-二叉树的存储结构和遍历

return(p); }
建立二叉树
以字符串的形式“根左子树右子树”定义 一棵二叉树
1)空树 2)只含一个根 结点的二叉树 A 3)
B C
A
以空白字符“ ”表示
以字符串“A ”表示
D
以下列字符串表示 AB C D
建立二叉树 A B C C
T
A ^ B ^ C^ ^ D^
D
建立二叉树
Status CreateBiTree(BiTree &T) {
1 if (!T) return;
2 Inorder(T->lchild, visit); // 遍历左子树 3 visit(T->data); } // 访问结点 4 Inorder(T->rchild, visit); // 遍历右子树
后序(根)遍历
若二叉树为空树,则空操

左 子树
右 子树
作;否则, (1)后序遍历左子树; (2)后序遍历右子树; (3)访问根结点。
统计二叉树中结点的个数
遍历访问了每个结点一次且仅一次
设置一个全局变量count=0
将visit改为:count++
统计二叉树中结点的个数
void PreOrder (BiTree T){ if (! T ) return; count++; Preorder( T->lchild); Preorder( T->rchild); } void Preorder (BiTree T,void( *visit)(TElemType& e)) { // 先序遍历二叉树 1 if (!T) return; 2 visit(T->data); // 访问结点 3 Preorder(T->lchild, visit); // 遍历左子树 4 Preorder(T->rchild, visit);// 遍历右子树 }

二叉树实验心得(优秀5篇)

二叉树实验心得(优秀5篇)二叉树实验心得篇1二叉树实验心得在进行二叉树实验的过程中,我不仅掌握了一个重要的数据结构——二叉树,还从中体验到了深入理解一个数据结构的魅力和乐趣。

在实验开始时,我首先学习了二叉树的基本概念,如节点、左子树、右子树等。

我明白了二叉树是一种重要的数据结构,它具有层次结构,每个节点最多有两个子节点,且没有祖先节点的左或右子树中的任何一个节点。

接下来,我学习了二叉树的遍历,包括前序遍历、中序遍历和后序遍历。

通过实验,我明白了这些遍历方式的实现原理,并能够灵活地应用它们。

此外,我还学习了递归和迭代两种方法来实现这些遍历方式,这两种方法各有优点和缺点,我深入了解了它们之间的差异。

在进行实验的过程中,我遇到了一些问题,如递归方法导致的栈溢出,以及中序遍历中的栈和队列的使用。

我通过查阅资料和讨论,解决了这些问题,并从中获得了宝贵的经验。

通过这次实验,我更加深入地理解了二叉树的结构和遍历方式,并能够在实际应用中灵活使用。

我明白了数据结构的重要性,以及深入理解数据结构的过程中的乐趣。

同时,我也学会了如何解决问题,并从中获得了宝贵的经验。

总的来说,这次实验是一个非常有意义的经历,我不仅掌握了新的知识,还锻炼了自己的解决问题的能力。

我相信,这次实验将对我未来的学习和工作产生积极的影响。

二叉树实验心得篇2二叉树实验心得这次实验我们了解了二叉树的基本概念,包括二叉树、结点、左子树、右子树、祖先节点等概念。

通过实验,我们对二叉树的性质有了更深刻的理解,比如二叉树只有左子树或右子树,没有左右子树的情况,即空子树。

在实现二叉树时,我们了解了二叉树节点的定义和插入节点的多种方法,包括先插法、后插法等。

我们还学会了利用二叉树来解决实际问题,比如快速查找等问题。

在实验过程中,我们对二叉树的知识进行了深入探究,收获颇丰。

通过这次实验,我对二叉树有了更深刻的认识,明白了二叉树在计算机科学中的重要性。

同时,我对自己的编程能力也有了新的认识,发现自己可以在理解算法的基础上更好地实现它们。

树的操作实验报告

实验名称:树的操作实验实验目的:1. 理解树的基本概念和操作。

2. 掌握树的创建、插入、删除、查找等基本操作。

3. 熟悉树在计算机科学中的应用。

实验环境:1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:Eclipse实验内容:1. 树的基本概念2. 树的创建3. 树的插入4. 树的删除5. 树的查找6. 树的应用实验步骤:一、树的基本概念1. 树的定义:树是一种非线性数据结构,由若干节点组成,每个节点有一个唯一的父节点(根节点除外),除了根节点外,其他节点都有一个子节点。

2. 树的术语:- 节点:树中的数据元素。

- 父节点:节点的直接前驱节点。

- 子节点:节点的直接后继节点。

- 根节点:没有父节点的节点。

- 叶节点:没有子节点的节点。

- 节点的度:节点拥有的子节点个数。

- 树的深度:根节点到叶节点的最长路径长度。

二、树的创建1. 创建二叉树:```javapublic class BinaryTree {private TreeNode root;public BinaryTree() {root = null;}public void createTree(int[] data) {if (data == null || data.length == 0) {return;}root = new TreeNode(data[0]);int i = 1;Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root);while (!queue.isEmpty()) {TreeNode node = queue.poll();if (i < data.length && data[i] != 0) {node.left = new TreeNode(data[i]); queue.offer(node.left);i++;}if (i < data.length && data[i] != 0) { node.right = new TreeNode(data[i]); queue.offer(node.right);i++;}}}}```2. 创建二叉搜索树:```javapublic class BinarySearchTree {private TreeNode root;public BinarySearchTree() {root = null;}public void createTree(int[] data) {if (data == null || data.length == 0) {return;}for (int i = 0; i < data.length; i++) {root = insert(root, data[i]);}}private TreeNode insert(TreeNode node, int data) { if (node == null) {return new TreeNode(data);}if (data < node.data) {node.left = insert(node.left, data);} else if (data > node.data) {node.right = insert(node.right, data);}return node;}}```三、树的插入1. 在二叉树中插入节点:```javapublic void insert(TreeNode node, int data) {if (node == null) {return;}if (data < node.data) {insert(node.left, data);} else if (data > node.data) {insert(node.right, data);}}```2. 在二叉搜索树中插入节点:```javaprivate TreeNode insert(TreeNode node, int data) { if (node == null) {return new TreeNode(data);}if (data < node.data) {node.left = insert(node.left, data);} else if (data > node.data) {node.right = insert(node.right, data);}return node;}```四、树的删除1. 在二叉树中删除节点:```javapublic void delete(TreeNode node, int data) {if (node == null) {return;}if (data < node.data) {delete(node.left, data);} else if (data > node.data) {delete(node.right, data);} else {if (node.left == null && node.right == null) { node = null;} else if (node.left == null) {node = node.right;} else if (node.right == null) {node = node.left;} else {TreeNode minNode = findMin(node.right);node.data = minNode.data;delete(node.right, minNode.data);}}}```2. 在二叉搜索树中删除节点:```javaprivate TreeNode delete(TreeNode node, int data) {if (node == null) {return null;}if (data < node.data) {node.left = delete(node.left, data);} else if (data > node.data) {node.right = delete(node.right, data);} else {if (node.left == null && node.right == null) { node = null;} else if (node.left == null) {node = node.right;} else if (node.right == null) {node = node.left;} else {TreeNode minNode = findMin(node.right);node.data = minNode.data;node.right = delete(node.right, minNode.data); }}return node;}```五、树的查找1. 在二叉树中查找节点:```javapublic TreeNode search(TreeNode node, int data) {if (node == null) {return null;}if (data == node.data) {return node;} else if (data < node.data) {return search(node.left, data);} else {return search(node.right, data);}}```2. 在二叉搜索树中查找节点:```javapublic TreeNode search(TreeNode node, int data) {if (node == null) {return null;}if (data == node.data) {return node;} else if (data < node.data) {return search(node.left, data);} else {return search(node.right, data);}}```六、树的应用1. 堆排序:利用二叉堆的属性,实现高效排序。

数据结构实验报告及心得体会

数据结构实验报告及心得体会一、引言数据结构是计算机科学中的重要基础课程,通过实验环节的学习,我们能够更好地掌握和应用数据结构的概念、算法和操作。

本报告旨在总结和分享我们进行的数据结构实验,并提出相应的心得体会。

二、实验一:线性表的实现与应用1. 实验目的本实验旨在通过实现和应用线性表的基本操作,掌握线性表的存储结构和算法。

2. 实验内容我们选择了顺序表和链表两种线性表的实现方式,并实现了插入、删除和查找等基本操作。

通过实验,我们发现顺序表适用于元素个数较少、频繁查找的情况,而链表适用于插入和删除操作较多、元素个数不确定的情况。

3. 实验心得通过实验一,我们深刻认识到数据结构的不同实现方式对算法的影响。

选择合适的数据结构可以提高算法效率,提高程序的性能。

同时,我们也意识到了在实际应用中,根据问题的具体特点选择不同的数据结构才能得到最优解。

三、实验二:栈与队列的应用本实验旨在通过实现和应用栈和队列的基本操作,掌握栈和队列的特性及其在实际应用中的作用。

2. 实验内容我们分别实现了顺序栈、链式栈、顺序队列和链式队列,并实现了入栈、出栈、入队和出队等基本操作。

我们发现栈适用于实现回溯算法、递归算法等,而队列适用于广度优先搜索、线程池等场景。

3. 实验心得通过实验二,我们进一步理解了栈和队列在实际编程中的运用。

它们提供了方便的数据结构,帮助我们解决了许多实际问题。

同时,实验过程中,我们也发现了栈溢出的问题,意识到了合理管理栈空间的重要性。

四、实验三:树与二叉树的实现与应用1. 实验目的本实验旨在通过实现和应用树和二叉树的基本操作,掌握树和二叉树的存储结构和算法。

2. 实验内容我们实现了树和二叉树的基本操作,包括创建、插入、删除和遍历等。

通过实验,我们发现树在表示具有部分层次结构的问题时更合适,而二叉树在表示递归结构时更加方便。

通过实验三,我们深入理解了树和二叉树的特性及其应用。

树和二叉树是许多高级数据结构的基础,熟练掌握它们的操作对于解决实际问题非常重要。

树的应用

实验项目名称:树的应用(所属课程:数据结构--用C语言描述)院系:计算机科学与信息工程学院专业班级:网络工程姓名:0000000 学号:0000000000 实验日期:2016.11.16 实验地点:A-06 609 合作者:指导教师:孙高飞本实验项目成绩:教师签字:日期:(以下为实验报告正文)一、实验目的通过本实验使学生深刻理解二叉树的性质和存储结构,熟练掌握二叉树的遍历算法。

认识哈夫曼树、哈夫曼编码的作用和意义。

实验要求:建一个二叉树并按照前序、中序、后序三种方法遍历此二叉树,正确调试本程序。

能够建立一个哈夫曼树,并输出哈夫曼编码,正确调程序。

二、实验条件Windows7系统的电脑,vc++6.0软件,书本《数据结构--用c语言描述》三、实验内容1.根据书上的代码,利用先序遍历和中序遍历创建一个二叉树。

2.根据167页算法6.6实现二叉树的后序遍历统计叶子节点数目。

3.根据169页算法6.8实现二叉树的后序遍历求二叉树的高度。

4.根据170页算法6.10实现按树状打印二叉树。

5.根据192页算法6.17用静态三叉链表实现哈夫曼树的类型定义。

6.根据192页算法6.18创建哈夫曼树。

四、实验步骤1.编写头文件。

2.根据161页代码,“用c语言定义二叉树的二叉链表结点结构。

3.根据168页算法6.7用扩展先序遍历序列创建二叉链表,创建createBiTree 函数。

4.根据164页算法6.1先序遍历二叉树和算法6.2中序遍历二叉树,创建preOrder函数,midOrder函数确定唯一二叉树。

5.创建main函数,依次调用createBiTree函数,preOrder函数,midOrder函数按照遍历顺序输出二叉树元素。

6.根据167页算法6.6后序遍历统计叶子结点数目,创建leaf函数统计二叉树叶子结点数目。

7.修改main函数在(7)中的main函数调用leaf函数统计二叉树叶子结点数目。

8.根据169页算法6.8后序遍历求二叉树高度的地柜算法,创建PostTreeDepth 函数计算二叉树的高度。

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

数据结构实验二 树的应用(代码&测试界面)
//Cosmetics_Info.h
#include
#include
#include

typedef struct { //化妆品信息的结构体
char brandname[10]; //品牌名
double price; //价格
}datatype;

typedef struct node{ //二叉排序树链表的结点结构
datatype data; //结点信息
struct node *lchild, *rchild; //指向左孩子与右孩子的指针
} bintnode;

typedef bintnode *bintree; //结点指针类型
bintree root; //指向二叉树根结点的指针

void InsertBintree(bintree *t, datatype addnode) //创建新结点
{
bintree f = NULL, p = *t; //p指向根结点
while(p) //每次从根结点开始比较,查找插入位置
{
if
( strcmp(addnode.brandname,p->data.brandname)==0&&addnode.price==p->data.price )
{
printf("已录入该化妆品信息,本次录入无效!\n");
return;
}//若二叉排序树中已含addnode,则无需插入,ruturn退出函数
f = p; //f用于保存新结点的最终插入位置
p = ((addnode.price) < (p->data.price))? p->lchild:p->rchild;
}
p=(bintree)malloc(sizeof(bintnode)); //生成待插入的新结点
p->data=addnode; //将新结点加到树上
p->lchild=p->rchild=NULL;
if(*t==NULL) *t=p; //原树为空,将值赋值给根结点
else {
if(addnode.pricedata.price)
f->lchild=p;
else f->rchild=p;
}
}
bintree CreatBintree() //创建二叉排序树链表
{
bintree t = NULL;
datatype addnode; //录入化妆品信息
printf("\"end\",\"-1\"为结束标记:\n");
scanf("%s",addnode.brandname);
scanf("%lf",&addnode.price);
while((strcmp(addnode.brandname,"end")!=0)||(addnode.price!=-1))
{
InsertBintree(&t,addnode); //将addnode插入二叉排序树
scanf("%s",addnode.brandname);
scanf("%lf",&addnode.price);
}
printf("化妆品信息二叉排序树建立成功!\n");
return t; //返回二叉排序树的根地址
}

void inorder(bintree t) //递归实现二叉树中序遍历输出
{
if(t){
inorder(t->lchild);
printf("\t\t 品牌名:%s ",t->data.brandname);
printf("\t价格:%g元\n",t->data.price);
inorder(t->rchild);
}
}

//main.c
#include
#include
#include
#include "Cosmetics_Info.h"

int main() {
int s=1;
int set;
while(s) {
printf("\t\t╔───────────╗\n");
printf("\t\t│简单化妆品信息处理系统│\n");
printf("\t\t╠───────────╣\n");
printf("\t\t│ 1.录入化妆品信息 │\n");
printf("\t\t│ 2.输出化妆品信息 │\n");
printf("\t\t│ 3.退出系统 │\n");
printf("\t\t╚───────────╝\n");
printf("选择操作:");
scanf("%d",&set);
switch(set){
case 1:root=CreatBintree();break;
case 2:{
printf("化妆品品牌价格一览表(价格从低到高):\n");
printf("\t\t╔─────────────────────╗\n");
inorder(root);
printf("\t\t╚─────────────────────╝\n");
break;
}
case 3:s=0;printf("\t系统退出成功!\n");break;
default:printf("无该选项对应的操作!\n");
}
system("pause");
system("cls");
}
return 0;
}

测试界面在下一页
1507084143 刘安光
1.录入化妆品信息
2.输出化妆品信息
3.退出系统

相关文档
最新文档