二叉排序树实验报告
数据结构试验报告 二叉排序树的操作
数据结构实验报告班级:信息与计算科学专业1102班学号: 1108060214姓名:朱晓东设计日期:2013.6.6西安科技大学计算机学院1.实验报告编写一个演示运用二叉排序树进行数据的的排序、插入、删除、查找等操作的程序。
2.需求分析本演示程序用vc6.0编写,完成数据的排序功能,同时能够进行数据的创建、插入、删除、查找。
(1)输入的形式和输入值的范围:创建二叉排序树时输入较多的值;插入元素时需要输入插入的元素的值;删除元素时输入元素的值;查找操作时需要输入元素的值。
所有输入中,元素的值都是整数。
(2)输出的形式:在创建、插入、删除的操作后,均显示操作后的元素的排序状况,有小到大排序。
(3)程序所能达到的功能:完成二叉排序树的生成、插入、删除、查找操作。
(4)测试数据:①插入操作中依次输入10 9 11 8 12 0(本程序是以0元素为为结束标志);②查找操作中输入13;③插入操作中输入13;3概要设计本程序包含8个函数:(1)主函数main()(2)创建二叉排序树函数BSTCreate(BiTree* bt)(3)显示操作菜单函数menu()(4)显示二叉排序树的内容函数BSTShow(BiTree bt)(5)插入元素函数BSTInsert(BiTree* bt,DataType key)(6)删除元素函数BSTDelete(BiTree* bt,DataType key)(7)查找元素函数BSTSearch(BiTree bt,DataType key)(8)查找要删除的元素的函数DeleteNode(BiTree* bt)各函数之间的关系如下:BSTCreate(BiTree* bt)menu()BSTShow(BiTree bt)mainBSTInsert(BiTree* bt,DataType key)BSTDelete(BiTree* bt,DataType key) DeleteNode(BiTree* bt)BSTSearch(BiTree bt,DataType key)4.详细设计实现概要设计中定义的所有数据类型,对每个操作给出伪码算法。
数据结构_二叉排序树实验报告
日 期:
实验成绩:
批阅日期:
【本文档内容可以自由复制内容或自由编辑修改内容期待你的好评和关注,我们将会做得更好】
五、概要设计
为了实现上述操作,应以构造体为存储构造。实现如下:
struct node
{
int key;//关键字的值
struct node *lchild,*rchild;//左右指针
}BSTNode,*BSTree;
1、根本操作:
〔1〕struct node
{
int key;//关键字的值
struct node *lchild,*rchild;//左右指针
2、输出的形式:建立好的排序二叉树的中序遍历结果。
3、程序所能到达的功能:能够通过键盘输入建立二叉排序树,并在建立完立即在屏幕显示中序遍历结果的程序
4、测试数据:输入45 24 53 12 28 90并用空格将数隔开,以0作为完毕符,如:
输入45 24 53 12 28 90
输出的中序遍历结果为:12 24 28 45 53 90
}BSTNode,*BSTree;
void InsertBST(BSTree *bst,int key) //二叉排序树的插入结点
{
BSTree s;
if(*bst==NULL)
{
s=(BSTree)malloc(sizeof(BSTNode));
s->key=key;
s->lchild=NULL;
{
if(bt!=NULL)
{
inorder(bt->lchild);
printf("%3d",bt->key) ;
inorder(bt->rchild);
实验报告:二叉树
实验报告:二叉树第一篇:实验报告:二叉树实验报告二叉树一实验目的1、进一步掌握指针变量,动态变量的含义;2、掌握二叉树的结构特性以及各种存储结构的特点及适用范围。
3、掌握用指针类型描述、访问和处理二叉树的运算。
4、熟悉各种存储结构的特征以及如何应用树结构解决具体问题。
二实验原理树形结构是一种应用十分广泛和重要的非线性数据结构,是一种以分支关系定义的层次结构。
在这种结构中,每个数据元素至多只有一个前驱,但可以有多个后继;数据元素之间的关系是一对多的层次关系。
树形结构主要用于描述客观世界中具有层次结构的数据关系,它在客观世界中大量存在。
遍历二叉树的实质是将非线性结构转为线性结构。
三使用仪器,材料计算机 2 Wndows xp 3 VC6.0四实验步骤【问题描述】建立一个二叉树,请分别按前序,中序和后序遍历该二叉树。
【基本要求】从键盘接受输入(按前序顺序),以二叉链表作为存储结构,建立二叉树(以前序来建立),并采用递归算法对其进行前序,中序和后序遍历,将结果输出。
【实现提示】按前序次序输入二叉树中结点的值(一个整数),0表示空树,叶子结点的特征是其左右孩子指针为空。
五实验过程原始记录基本数据结构描述; 2 函数间的调用关系;用类C语言描述各个子函数的算法;附录:源程序。
六试验结果分析将实验结果分析、实验中遇到的问题和解决问题的方法以及关于本实验项目的心得体会,写在实验报告上。
第二篇:数据结构-二叉树的遍历实验报告实验报告课程名:数据结构(C语言版)实验名:二叉树的遍历姓名:班级:学号:时间:2014.11.03一实验目的与要求1.掌握二叉树的存储方法2.掌握二叉树的三种遍历方法3.实现二叉树的三种遍历方法中的一种二实验内容• 接受用户输入一株二叉树• 输出这株二叉树的前根, 中根, 后根遍历中任意一种的顺序三实验结果与分析//*********************************************************** //头文件#include #include //*********************************************************** //宏定义#define OK 1 #define ERROR 0 #define OVERFLOW 0//*********************************************************** typedef struct BiTNode { //二叉树二叉链表存储结构char data;struct BiTNode *lChild,*rChild;}BiTNode,*BiTree;//******************************** *************************** int CreateBiTree(BiTree &T){ //按先序次序输入二叉中树结点的值,空格表示空树//构造二叉链表表示的二叉树T char ch;fflush(stdin);scanf(“%c”,&ch);if(ch==' ')T=NULL;else{ if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))return(OVERFLOW);T->data=ch;Creat eBiTree(T->lChild);CreateBiTree(T->rChild);} return(OK);} //********************************************************* void PreOrderTraverse(BiTree T){ //采用二叉链表存储结构,先序遍历二叉树的递归算法if(T){ printf(“%c”,T->data);PreOrderTraverse(T->lChild);PreOrd erTraverse(T->rChild);} } /***********************************************************/ void InOrderTraverse(BiTree T){ //采用二叉链表存储结构,中序遍历二叉树的递归算法if(T){ InOrderTraverse(T->lChild);printf(“%c”,T->data);InOrderT raverse(T->rChild);} }//*********************************************************** void PostOrderTraverse(BiTree T){ //采用二叉链表存储结构,后序遍历二叉树的递归算法if(T){ PostOrderTraverse(T->lChild);PostOrderTraverse(T->rChild) ;printf(“%c”,T->data);} }//*********************************************************** void main(){ //主函数分别实现建立并输出先、中、后序遍历二叉树printf(“please input your tree follow the PreOrder:n”);BiTNode *Tree;CreateBiTree(Tree);printf(“n先序遍历二叉树:”);PreOrderTraverse(Tree);printf(“n中序遍历二叉树:”);InOrderTraverse(Tree);printf(“n后序遍历二叉树:”);PostOrderTraverse(Tree);}图1:二叉树的遍历运行结果第三篇:数据结构二叉树操作验证实验报告班级:计算机11-2 学号:40 姓名:朱报龙成绩:_________实验七二叉树操作验证一、实验目的⑴ 掌握二叉树的逻辑结构;⑵ 掌握二叉树的二叉链表存储结构;⑶ 掌握基于二叉链表存储的二叉树的遍历操作的实现。
二叉排序树的实验报告
二叉排序树的实验报告二叉排序树的实验报告引言:二叉排序树(Binary Search Tree,简称BST)是一种常用的数据结构,它将数据按照一定的规则组织起来,便于快速的查找、插入和删除操作。
本次实验旨在深入了解二叉排序树的原理和实现,并通过实验验证其性能和效果。
一、实验背景二叉排序树是一种二叉树,其中每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。
这种特性使得在二叉排序树中进行查找操作时,可以通过比较节点的值来确定查找的方向,从而提高查找效率。
二、实验目的1. 理解二叉排序树的基本原理和性质;2. 掌握二叉排序树的构建、插入和删除操作;3. 验证二叉排序树在查找、插入和删除等操作中的性能和效果。
三、实验过程1. 构建二叉排序树首先,我们需要构建一个空的二叉排序树。
在构建过程中,我们可以选择一个节点作为根节点,并将其他节点插入到树中。
插入节点时,根据节点的值与当前节点的值进行比较,如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
重复这个过程,直到所有节点都被插入到树中。
2. 插入节点在已有的二叉排序树中插入新的节点时,我们需要遵循一定的规则。
首先,从根节点开始,将新节点的值与当前节点的值进行比较。
如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
如果新节点的值与当前节点的值相等,则不进行插入操作。
3. 删除节点在二叉排序树中删除节点时,我们需要考虑不同的情况。
如果要删除的节点是叶子节点,即没有左右子树,我们可以直接删除该节点。
如果要删除的节点只有一个子树,我们可以将子树连接到要删除节点的父节点上。
如果要删除的节点有两个子树,我们可以选择将其右子树中的最小节点或左子树中的最大节点替代该节点,并删除相应的替代节点。
四、实验结果通过对二叉排序树的构建、插入和删除操作的实验,我们得到了以下结果:1. 二叉排序树可以高效地进行查找操作。
数据结构实验-二叉排序树应用实验报告
实验报告实验课程:数据结构实验项目:实验四二叉排序树应用专业:计算机科学与技术班级:姓名:学号:指导教师:目录一、问题定义及需求分析(1)问题描述(2)实验任务(3)需求分析二、概要设计:(1)抽象数据类型定义(2)主程序流程(3) 模块关系三、详细设计(1)数据类型及存储结构(2)模块设计四、调试分析(1)调试分析(2)算法时空分析(3)经验体会五、使用说明(1)程序使用说明六、测试结果(1)运行测试结果截图七、附录(1)源代码一、问题定义及需求分析(1)实验目的二叉排序树应用问题描述互联网域名系统是一个典型的树形层次结构。
从根节点往下的第一层是顶层域,如cn、com等,最底层(第四层)是叶子结点,如www等。
因此,域名搜索可以构造树的结构完成;(2)实验任务设计基于二叉排序树的搜索互联网域名的程序。
(3)需求分析:1)采用二叉树的二叉链表存储结构。
2)完成二叉排序树的创建、插入、删除、查询操作。
3)可以考虑两棵二叉排序树的合并。
二、概要设计:(1)抽象数据类型定义:程序中定义了二叉排序树的节点类型;由数据域和左右孩子指针构成;指针类型为该节点类型,指向该类型的节点形成二叉排序树;数据域是由字符数组构成,用于存储节点数据信息。
(2)主程序流程:输入域名拆分域名并完成二叉排序树的创建调用功能函数进入功能菜单选择执行不同的操作(查找、插入、删除) 操作完毕后可选择返回功能函数继续执行操作或者结束程序(3)模块间的调用关系:创建二叉排序树功能函数查找插入选择结束三、详细设计采用二叉链表存储结构的二叉排序树的定义如下:typedef struct BiTNode{ElemType data[30]; //定义数据域类型为字符数组struct BiTNode *lchild, *rchild; //定义左右孩子节点指针}BiTNode, *BiTree;模块1-查找树中是否有待插入节点算法如下:int SearchBST(BiTree T, char *key, BiTree f, BiTree *p){if (!T) /* 查找不成功*/{*p = f;return 0;}else if(strcmp(key,T->data)==0) /* 查找成功*/{*p = T;return 1;}else if (strcmp(key,T->data)<0)return SearchBST(T->lchild, key, T, p); /* 若该节点小于当前节点,则在左子树中继续查找*/elsereturn SearchBST(T->rchild, key, T, p); /* 否则在右子树中继续查找*/ }模块2-插入节点算法如下:int InsertBST(BiTree *T, char *key){BiTree p,s;if (!SearchBST(*T, key, NULL, &p)) /* 查找不成功*/{s = (BiTNode*)malloc(sizeof(BiTNode));strcpy(s->data, key);s->lchild = s->rchild = NULL;if (!p)*T = s; /* 插入s为新的根结点*/else if (strcmp(key,p->data)<0)p->lchild = s; /* 插入s为左孩子*/elsep->rchild = s; /* 插入s为右孩子*/return 1;}elsereturn 0; /* 树中已有关键字相同的结点,不再插入*/}模块3-删除节点算法如下:int Delete(BiTree *p){BiTree q,s;if((*p)->rchild==NULL) /* 右子树空则只需重接它的左子树(待删结点是叶子也走此分支) */{q=*p;*p=(*p)->lchild;free(q);}else if((*p)->lchild==NULL) /* 只需重接它的右子树*/{q=*p;*p=(*p)->rchild;free(q);}else /* 左右子树均不空*/{q=*p;s=(*p)->lchild;while(s->rchild) /* 转左,然后向右到尽头(找待删结点的前驱)*/{q=s;s=s->rchild;}strcpy((*p)->data,s->data); /* s指向被删结点的直接前驱(将被删结点前驱的值取代被删结点的值)*/if(q!=*p)q->rchild=s->lchild; /* 重接q的右子树*/elseq->lchild=s->lchild; /* 重接q的左子树*/free(s);}return 1;}模块4-查找待删除节点的位置算法如下:int DeleteBST(BiTree *T,char *key){if(!*T) /* 不存在关键字等于key的数据元素*/return 0;else{if (strcmp(key,(*T)->data)==0) /* 找到关键字等于key的数据元素*/return Delete(T);else if (strcmp(key,(*T)->data)<0)return DeleteBST(&(*T)->lchild,key);/* 若待删除节点大于当前节点,则递归访问其左子树*/elsereturn DeleteBST(&(*T)->rchild,key);/* 否则访问右子树*/}}模块5-功能函数包括查找、插入和删除算法如下:void Gongneng(BiTNode *A){// 执行操作需将此树的根节点传入到此函数里面int k;char a[30],c[30],d[30];printf("请选择你的操作:\n");printf("1-查找\n");printf("2-删除\n");printf("3-插入\n");printf("输入:");scanf("%d",&k);switch(k){//通过switch语句执行不同的操作case 1 :system("cls");printf("请输入你要查找的节点:");scanf("%s",c);Search(A, c); //调用查找函数break;case 2:system("cls");printf("请输入你要删除的节点:");scanf("%s",a);if(!DeleteBST(&A,a))printf("\n不存在此节点!\n");else{printf("\n删除节点成功!\n\n删除后树的中序遍历结果如下:\n");InOrder(A);}break;case 3:system("cls");printf("请输入要插入的节点:");scanf("%s",d);if(!InsertBST(&A,d))printf("插入失败!要插入的节点已存在!\n");else{printf("\n插入成功!\n\n插入后树的中序遍历结果如下:\n");InOrder(A);}break;default : printf("输入数值错误!\n");}}四、调试分析问题及解决方法:在编写功能函数时,在参数的传递上出现了问题;无法正确的将根节点传入到功能函数里,导致功能函数无法正常运行;解决方法为:void Gongneng(BiTNode *A);时空分析:由于采用二叉链表的存储结构,所以在插入和删除算法的时间复杂度较低;而对于较多的数据元素形成的树时,查找算法在时间复杂度上不算简便;而存储方面,二叉链表构成的二叉排序树存储较为方便且空间利用率高;经验体会:二叉链表存储结构的存储密度较高,使用起来较为方便;而且在处理数据方面,二叉链表存储结构的处理性比较好,尤其是对插入和删除算法;五、使用说明第一步:点击运行按钮;第二步: 输入待输入的域名个数k;第三步:依次输入k个域名;第四步:回车,程序跳转至功能界面,根据提示输入想要执行的功能选项序号;第五步:回车后,针对各功能项有提示药查找、插入或者删除的节点;第六步:执行功能后,选择结束运行还是继续操作;第七步:若选择继续操作,则程序进入功能界面,可继续选择执行的功能;第八步:循环执行第四到七步;第九步:可在第六步选择退出程序;六、测试结果七、附录源代码:#include<stdio.h>#include<stdlib.h>#include<string.h>#define ElemType chartypedef struct BiTNode{ElemType data[30]; //定义数据域类型为字符数组struct BiTNode *lchild, *rchild; //定义左右孩子节点指针}BiTNode, *BiTree;int SearchBST(BiTree T, char *key, BiTree f, BiTree *p){if (!T) // 树为空,查找不成功{*p = f;return 0;}else if(strcmp(key,T->data)==0) // 查找成功{*p = T; //p指向查找到的节点return 1;}else if (strcmp(key,T->data)<0)return SearchBST(T->lchild, key, T, p); // 在左子树中继续查找elsereturn SearchBST(T->rchild, key, T, p); // 在右子树中继续查找}int InsertBST(BiTree *T, char *key){BiTree p,s;if (!SearchBST(*T, key, NULL, &p)) // 查找不成功{s = (BiTNode*)malloc(sizeof(BiTNode));//s作为插入节点strcpy(s->data, key);s->lchild = s->rchild = NULL;if (!p)*T = s; // 插入s为新的根结点else if (strcmp(key,p->data)<0)p->lchild = s; // 插入s为左孩子elsep->rchild = s; // 插入s为右孩子return 1;}elsereturn 0; // 树中已有关键字相同的结点,不再插入}int Search(BiTNode *N,char *key){ // 查找树中是否存在要插入的节点BiTNode *M;M=N;while(M!=NULL&&strcmp(M->data,key)!=0){ // 查找终止条件为树为空或者查找的节点数据与待查找的数据相同if(strcmp(M->data,key)<0)M=M->rchild; // 继续查找左子树elseM=M->lchild; // 继续查找右子树}if(!M)printf("查找失败!\n");elseprintf("查找成功!\n");}/* 从二叉排序树中删除结点p,并重接它的左或右子树。
二叉排序树实验报告
深圳大学实验报告
课程名称:数据结构实验与课程设计
实验项目名称:二叉排序树实验
学院:计算机与软件学院
专业:
指导教师:
报告人:学号:班级: 3班
实验时间: 2012-11-28 实验报告提交时间: 2012-12-5
教务部制
int main(int argc,char *argv[])
{
int t[32];
int i,j,Key;
int TestNum,SampleNum;
// freopen("cin.txt","r",stdin);
// freopen("cout.txt","w",stdout);
BiSortTree *BST=new BiSortTree;
cin>>TestNum;
for(i=0;i<TestNum;i++){
cin>>SampleNum;
for(j=0;j<SampleNum;j++) cin>>t[j];
BST->CreateBST(t,SampleNum);
cin>>Key;
BST->SearchBST(Key);
cout<<BST->BisSuccess<<" "<<BST->BisPos <<" "<<BST->BisCount<<endl;
}
return 0;
}
运行截图:
2、教师批改学生实验报告时间应在学生提交实验报告时间后10日内。
数据结构二叉排序树实验报告
实验报告课程名:数据结构(C语言版)实验名:二叉排序树姓名:班级:学号:撰写时间:一实验目的与要求1.掌握二叉排序树上进行插入和删除的操作2.利用 C 语言实现该操作二实验内容•对于一个线形表, 利用不断插入的方法, 建立起一株二叉排序树•从该二叉排序树中删除一个叶子节点, 一个只有一个子树的非叶子节,一个有两个子树的非叶子节点。
三实验结果与分析#include<>#include<>删结点是叶子结点,直接删除if(p->left == NULL && p->right == NULL){删结点只有左子树else if(p->left && !(p->right)){p->left->parent=p->parent;删结点只有右孩子else if(p->right && !(p->left)){p->right->parent=p->parent;删除的结点既有左孩子,又有右孩子//该结点的后继结点肯定无左子树(参考上面查找后继结点函数)//删掉后继结点,后继结点的值代替该结点else{//找到要删除结点的后继q=searchSuccessor(p);temp=q->key;//删除后继结点deleteNode(root,q->key);p->key=temp;}return 1;}//创建一棵二叉查找树void create(PNode* root,KeyType *keyArray,int length) {int i;//逐个结点插入二叉树中for(i=0;i<length;i++)inseart(root,keyArray[i]);}int main(void){int i;PNode root=NULL;KeyType nodeArray[11]={15,6,18,3,7,17,20,2,4,13,9}; create(&root,nodeArray,11);for(i=0;i<2;i++)deleteNode(&root,nodeArray[i]);printf("%d\n",searchPredecessor(root)->key);printf("%d\n",searchSuccessor(root)->key);printf("%d\n",searchMin(root)->key);printf("%d\n",searchMax(root)->key);printf("%d\n",search(root,13)->key);return 0;}图1:二叉树排序实验结果。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为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,失败。
对于二叉排序树的实现的实践成果报告
对于二叉排序树的实现的实践成果报告一、二叉树序数算法的内容二叉排序树的实现,用顺序和二叉链表作存储结构。
首先,以回车(’\n’)为输入结束标志,输入数列L,生成一棵二叉排序树T;然后,对二叉排序树T作中序遍历,输出结果;最后,输入元素x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作中序遍历(执行操作2);否则输出信息“无x”;二、算法流程1.用C++实现二叉排序树的源代码2.建立一个二叉树3.在一棵二叉排序树中插入一个数4.在一个二叉排序树查找一个数是否存在5.在一个二叉排序树删除一个给定的值6.显示一个二叉排序树7.删除一棵整二叉排序树8.进行对二叉树的基本操作三、算法的应用领域和作用1.基于二叉排序树的缓冲机制在污染源监控系统中的研究传统意义上的污染源在线自动监控系统的数据查询采用顺序查找法,由于其时间复杂度高,导致在数据量巨大的场合下效率低下。
本文研究与实现基于二叉排序树的数据缓冲机制的污染源在线自动监控系统,提高监测污染物的效率,降低查询时间复杂度。
树形目录的存储结构比线性表结构的组织形式更灵活,所以对于数据量大的信息通常采用树形结构存储。
污染物数据存储于关系数据库中,查询时需要频繁地访问数据库。
从数据库中获得一个数据项所需要的计算机指令数往往比从服务器中获得一个文件要大一到两个数量级,影响系统运行的整体性能。
在多数系统中对某一对象重复访问,通常将生成数据进行缓冲处理,有利于系统性能的提高。
2. 缓冲实例的产生2.1系统缓冲机制缓冲机制主要是基于被访问数据以减少网络传输、提高检索效率为目的。
动态的缓冲是客户端通过网络访问服务器动态生成的,广域网环境中客户端请求的响应时间与请求传输时间、协议处理时间、数据装载时间、数据传输时间、数据表示时间有关。
在这种环境中,缓冲主要是为了减少请求时间和数据的传输时间。
缓冲数据主要分为两部分,主要存储在服务器端。
数据对象的集合较为巨大,仅仅存放于硬盘上会直接影响访问速度。
二叉排序树的基本运算实验报告
软件技术基础实验七-----二叉排序树的基本运算班级:电信0901学号:0703090106姓名:蒋玮珂实验七二叉排序树的基本运算(1)实验题目:编写一个程序,实现二叉排序树运算,在此基础上设计一个主程序完成如下功能(1)由指定集合创建一棵二叉排序树bt,并以括号表示法输出(2)判断bt是否是一棵二叉树(3)采用非递归方法查找指定关键字的结点,并输出查找路径(2)实验目的:1、掌握二叉排序树的数据类型描述及特点。
2、掌握二叉排序树的存储结构的建立算法。
3、掌握二叉排序树的基本运算的实现,例如:查找,排序等。
(3)调试通过并正确执行给定功能要求的实验代码#include "stdafx.h"#include<stdio.h>#include<stdlib.h>#include <string.h>typedef int KeyType;int Count=0;typedef struct tnode{KeyType key;struct tnode *lchild,*rchild;}BSTNode;//定义二叉排序树BSTNode *BSTSearch(BSTNode *bt,KeyType k)//非递归查找算法{BSTNode *p=bt;while (p!=NULL && p->key!=k){if (k<p->key)p=p->lchild; //沿左子树查找elsep=p->rchild; //沿右子树查找}return(p);}BSTNode *SearchBST(BSTNode *bt,KeyType k,FILE *fp2){BSTNode *p=bt;int flag=0;while (p!=NULL)//二叉排序树不为空{if(p->key==k)//查找成功{ fprintf(fp2,"%d",p->key);flag=1;break;}if(k<p->key)//查找不成功,到下一层继续查找{ fprintf(fp2,"%d",p->key);fputs("-->",fp2);p=p->lchild;}//查找左子树else{ fprintf(fp2,"%d",p->key);fputs("-->",fp2);p=p->rchild;}//查找右子树}if(flag==0){ fputs("找不到值为k的结点:\n",fp2);p=NULL;}return p;}int InsertBST(BSTNode *&bt,KeyType k)//插入算法{BSTNode *f,*p=bt;while (p!=NULL){if (p->key==k)return(0);f=p;//查找过程中,f指向*p的父结点if (p->key>k)p=p->lchild;//在左子树中查找elsep=p->rchild;//在右子树中查找}p=new BSTNode;//建立新结点p->key=k;p->lchild=p->rchild=NULL;if (bt==NULL) //原树为空时,*p作为根结点插入bt=p;else if (k<f->key)f->lchild=p; //插入*p作为*f的左孩子elsef->rchild=p; //插入*p作为*f的右孩子return(1);}void CreateBST(BSTNode *&bt,KeyType str[],int n)//二叉树的生成算法{bt=NULL; //设置二叉排序树的初态为空int i=0;while (i<n){InsertBST(bt,str[i]); //将关键字str[i]插入二叉排序树bt中i++;}}void inorder(BSTNode *t,int b[])//中序遍历{if(t!=0){inorder(t->lchild,b);b[Count++]=t->key;inorder(t->rchild,b);}}void BSTdisp(BSTNode *bt,FILE *fp2){if(bt!=NULL){ fprintf(fp2,"%d",bt->key);if(bt->lchild !=NULL||bt->rchild !=NULL){ putc('(',fp2);BSTdisp(bt->lchild,fp2);if(bt->rchild !=NULL)putc(',',fp2);BSTdisp(bt->rchild,fp2);putc(')',fp2);}}}void main(){int n,k,b[100],a[200];bool flag=false;BSTNode *bt=NULL;FILE *fp,*fp1,*fp2,*fp3;fp=fopen("number.txt","r");//读入元素个数nfscanf(fp,"%d",&n);fp1=fopen("data.txt","r");//读入结点数据for(int i=0;i<n;i++)fscanf(fp1,"%d",&a[i]);fp2=fopen("outcome.txt","w");//写入程序结果CreateBST(bt,a,n);fputs("括号表示法输出BT如下:\n",fp2);BSTdisp(bt,fp2);fprintf(fp2,"\n");inorder(bt,b);for(i=0;i<Count-1;i++){ if(b[i]>b[i+1])flag=true;}if(flag)fputs("该二叉树不是二叉排序树!\n",fp2);elsefputs("该二叉树是二叉排序树!\n",fp2);fp3=fopen("datafind.txt","r");//读入要查找的元素k fscanf(fp3,"%d",&k);fprintf(fp2,"非递归查找路径如下:\n");SearchBST(bt,k,fp2);fclose(fp);fclose(fp1);fclose(fp2);fclose(fp3);}(4)实验结果截图。
数据结构二叉排序树实验报告
*bst=s;
}
else if(key<(*bst)->key)
InsertBST(&((*bst)->lchild),key);//将s插入左子串
else if(key>(*bst)->key)
InsertBST(&((*bst)->rchild),key);//将s插入右子串
InsertBST(BSTree *bst,int key)
inorder(BSTree bt)
3、完整的程序:
#include"stdio.h"
#include"malloc.h"
typedef struct node
{
int key;//关键字的值
struct node *lchild,*rchild;//左右指针
}BSTNode,*BSTree;
元素类型为整形和指针形。
2、每个模块的分析:
(1)主程序模块:
main()
{
BSTree bt;
printf("please insert the numbers( 以0作为结束标志):\n");
CreateBST(&bt); /*构造排序二叉树*/
printf("\n中序遍历结果是:");
s->rchild=NULL;
*bst=s;
}
else if(key<(*bst)->key)
InsertBST(&((*bst)->lchild),key);//将s插入左子串
else if(key>(*bst)->key)
实验报告 实验三 二叉排序树的建立和查找
实验三二叉排序树的建立和查找一、实验目的1.掌握二叉排序树的建立算法2.掌握二叉排序树查找算法。
二、实验环境操作系统和C语言系统三、预习要求复习二叉排序树的生成及查找算法,编写完整的程序。
四、实验内容实现二叉排序树上的查找算法。
具体实现要求:用二叉链表做存储结构,输入键值序列,建立一棵二叉排序树并在二叉排序树上实现查找算法。
五、参考算法#include <stdio.h>#include <stdlib.h>typedef int InfoType;typedef int KeyType; /*假定关键字类型为整数*/typedef struct node /*结点类型*/{KeyType key; /*关键字项*/InfoType otherinfo; /*其它数据域,InfoType视应用情况而定,下面不处理它*/struct node *lchild,*rchild; /*左右孩子指针*/}BSTNode;typedef BSTNode *BSTree; /*BSTree是二叉排序树的类型*/BSTNode *SearchBST(BSTree T,KeyType key){ /*在二叉排序树T上查找关键字为key的结点,成功时返回该结点位置,否则返回NULL*/if(T==NULL||key==T->key) /*递归的终结条件*/return T; /*若T为空,查找失败;否则成功,返回找到的结点位置*/if(key<T->key)return SearchBST(T->lchild,key);elsereturn SearchBST(T->rchild,key); /*继续在右子树中查找*/}void InsertBST(BSTree *T,int key){ /*插入一个值为key的节点到二叉排序树中*/BSTNode *p,*q;if((*T)==NULL){ /*树为空树*/(*T)=(BSTree)malloc(sizeof(BSTNode));(*T)->key=key;(*T)->lchild=(*T)->rchild=NULL;}else{p=(*T);while(p){q=p;if(p->key>key)p=q->lchild;else if(p->key<key)p=q->rchild;else{printf("\n 该二叉排序树中含有关键字为%d的节点!\n",key);return;}}p=(BSTree)malloc(sizeof(BSTNode));p->key=key;p->lchild=p->rchild=NULL;if(q->key>key)q->lchild=p;elseq->rchild=p;}}BSTree CreateBST(void){ /*输入一个结点序列,建立一棵二叉排序树,将根结点指针返回*/BSTree T=NULL; /*初始时T为空树*/KeyType key;scanf("%d",&key); /*读入一个关键字*/while(key){ /*假设key=0是输入结束标志*/ InsertBST(&T,key); /*将key插入二叉排序树T*/scanf("%d",&key); /*读入下一关键字*/}return T; /*返回建立的二叉排序树的根指针*/ }void ListBinTree(BSTree T) /*用广义表示二叉树*/{if(T!=NULL){printf("%d",T->key);if(T->lchild!=NULL||T->rchild!=NULL){printf("(");ListBinTree(T->lchild);if(T->rchild!=NULL)printf(",");ListBinTree(T->rchild);printf(")");}}}void main(){BSTNode *SearchBST(BSTree T,KeyType key);void InsertBST(BSTree *Tptr,KeyType key);BSTree CreateBST();void ListBinTree(BSTree T);BSTree T;BSTNode *p;int key;printf("请输入关键字(输入0为结束标志):\n");T=CreateBST();ListBinTree(T);printf("\n");printf("请输入欲查找关键字:");scanf("%d",&key);p=SearchBST(T,key);if(p==NULL)printf("没有找到%d!\n",key);elseprintf("找到%d!\n",key);ListBinTree(p);printf("\n");}实验中出现的问题及对问题的解决方案输入数据时,总是不能得到结果,原因是在建立二叉树函数定义中,是对指针的值进行了修改。
二叉排序树实验报告
二叉排序树的实现实验内容与要求1) 实现二叉排序树,包括生成、插入,删除;2) 对二叉排序树进行先根、中根、和后根非递归遍历;3) 每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。
实验方案1. 选择链表的方式来构造节点,存储二叉排序树的节点。
// 树的结构struct BSTNode {// 定义左右孩子指针struct BSTNode *lchild,*rchild;// 节点的关键字TElemType key; };int depth=0;// 定义一个struct BSTNode 类型的指针typedef BSTNode *Tree;2. 对树的操作有如下方法:// 创建二叉排序树Tree CreatTree(Tree T) ;// 二叉树的深度,返回一个int 值为该树的深度int TreeDepth(Tree T)// 树状输出二叉树,竖向输出void PrintTree(Tree T , int layer) ;// 查找关键字,如果关键字存在则返回所在节点的父节点,如果关键字不存在则返回叶子所在的节点Status SearchBST(Tree T , TElemType key , Tree f,Tree &p) ;// 向树中插入节点Status InsertBST(Tree &T , TElemType e) ;// 删除节点Status Delete(Tree &T) ;// 删除指定节点,调用Delete(Tree &T) 方法Status DeleteData(Tree &T , TElemType key) ;// 非递归先序遍历void x_print(Tree T);// 非递归中序遍历Void z_print(Tree T );// 非递归后序遍历void h_print(Tree T);3. 对二叉排序树非递归先根、中根、后根遍历,采用栈来存储一次遍历过的节点的形式来辅助实现// 自定义类型以SElemType 作为栈中指针返回的值的类型// 也就是要返回一个节点的指针typedef Tree SElemType;// 栈的结构struct Stack{// 栈底指针SElemType *base;// 栈顶指针SElemType *top;// 栈的容量int stacksize;};4. 栈的操作方法:// 创建一个空栈Status InitStack(Stack &S) // 获取栈顶元素并删除栈中该位置的元素SElemType Pop(Stack&S,SElemType &elem)// 获取栈顶元素返回栈顶元素不对栈做任何修改SElemType getTop(Stack S,SElemType&elem) // 删除栈顶元素Status DeleteTop(Stack &S)// 往栈中压入数据Status Push(Stack &S,SElemType elem)// 判断栈是否为空Status IsEmpty(Stack S)三、代码实现#include <iostream>#include <math.h> using namespace std;// 定义宏#define OK 1 #define ERROR 0#define STACK_INIT_SIZE 10#define STACK_INCREMENT 2// 定义宏分别为栈的初始容量和栈的增加容量#define STACK_INIT_SIZE 10 #define STACK_INCREMENT 2 typedef int TElemType;// 树的结构struct BSTNode{// 定义左右孩子指针struct BSTNode *lchild,*rchild;// 节点的关键字TElemType key;};int depth=0;// 定义一个struct BSTNode 类型的指针typedef BSTNode *Tree;// 自定义类型以SElemType 作为栈中指针返回的值的类型// 也就是要返回一个节点的指针typedef Tree SElemType;// 栈的结构struct Stack{// 栈底指针SElemType *base;// 栈顶指针SElemType *top;// 栈的容量int stacksize;};// 自定义类型typedef int Status;// 创建一个空栈Status InitStack(Stack &S){// 给栈指针分配空间S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));// 如果分配空间失败则退出if(!S.base)exit(OVERFLOW);// 栈底、栈顶指针相等表示栈为空//S.base=S.top;// 此句代码若以如上句格式则在执行时会出现内存非法访问的错误S.top=S.base;// 初始化栈的容量S.stacksize=STACK_INIT_SIZE;return OK;}// 获取栈顶元素并删除栈中该位置的元素SElemType Pop(Stack &S,SElemType &elem){if(S.top==S.base){cout<<"gai zhan yi jing wei kong "<<endl; return ERROR;}else{elem=*--S.top;}return elem;}// 获取栈顶元素返回栈顶元素不对栈做任何修改SElemType getTop(Stack S,SElemType &elem){// 如果为空栈则返回ERROR if(S.base==S.top){cout<<"gai zhan yi jing wei kong"<<endl; return ERROR;}// 如果栈不为空则返回栈顶元素else{elem=*(S.top-1);}return elem;}// 删除栈顶元素Status DeleteTop(Stack &S){// 判断栈是否为空if(S.base==S.top){cout<<"gai zhan yi jing wei kong "<<endl; return ERROR;}// 如果栈不为空则删除栈顶元素else{--S.top;} return OK;}// 往栈中压入数据Status Push(Stack &S,SElemType elem){// 如果栈的容量超过初始化容量则增加栈的容量if(S.top-S.base>=S.stacksize) {S.base=(SElemType*)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(SElemType)); if(!S.base) exit(OVERFLOW);S.top=S.base+S.stacksize; S.stacksize+=STACK_INCREMENT;}// 添加数据*S.top++=elem;return OK;}// 判断栈是否为空Status IsEmpty(Stack S) {if(S.base==S.top)return OK;elsereturn ERROR;}////////////////////////////////////////////////////////////////////////////// 以下的代码主要是对树的操作////////////////////////////////////////////////////////////////////////////////////////////////// 创建空树Status InitTree(Tree &T){T=NULL;return OK;}// 查找关键字// 如果关键字存在则返回所在节点的父节点// 如果关键字不存在则返回叶子所在的节点Status SearchBST(Tree T,TElemType key,Tree f,Tree &p) {if(!T){p=f;return ERROR;}else if(T->key==key){p=T; return OK;}else if(T->key>key)return SearchBST(T->lchild,key,T,p);else if(T->key<key)return SearchBST(T->rchild,key,T,p);}// 向树中插入节点Status InsertBST(Tree &T,TElemType e) {Tree p;if(!SearchBST(T,e,NULL,p)){Tree s=(Tree)malloc(sizeof(BSTNode)); s->key=e;s->lchild=s->rchild=NULL;if(!p){T=s;}else if(p->key>e){ p->lchild=s;}else if(p->key<e){ p->rchild=s;}}elsereturn ERROR;}// 创建二叉排序树Tree CreatTree(Tree T){TElemType elem;cout<<" 请输入数据,以0 结束输入操作"<<endl; cin>>elem;while(elem!=0 && elem>0){int k= InsertBST(T,elem);if(k){cout<<" 请输入数据,以0 结束输入操作"<<endl; cin>>elem;}else{cout<<" 插入错误或存在重复元素"<<endl;// 异常退出return ERROR;return T;// 删除节点Status Delete(Tree &T) {Tree p,q;if(T->lchild!=NULL && T->rchild!=NULL) {}p=T; q=T->lchild; T=q;while(q->rchild!=NULL){ q=q->rchild;} q->rchild=p->rchild;free(p); return OK;}if(T->rchild==NULL && T->lchild!=NULL) {p=T;T=T->lchild; free(p); return OK;}else if(T->lchild==NULL && T->rchild!=NULL) {p=T;T=T->rchild; free(p); return OK;else if(T->rchild==NULL && T->lchild==NULL) {T=NULL; free(T); return OK;}}// 删除指定节点Status DeleteData(Tree &T,TElemType key){if(!T){!"<<endl;cout<<" 找不到要删除的元素,请重新选择return ERROR;}if(T->key==key){Delete(T);}else if(T->key>key) DeleteData(T->lchild,key);else if(T->key<key) DeleteData(T->rchild,key);return OK;}// 先序遍历void x_print(Tree T) {//Tree f; Stack S; InitStack(S);}if(T==NULL){cout<<" 树为空"<<endl;while(T!=NULL || !IsEmpty(S)) {if(T!=NULL){cout<<T->key<<" ";Push(S,T);T=T->lchild;}else{Pop(S,T);T=T->rchild;}}}//z 中序遍历void z_print(Tree T ){// Tree f;Stack S;InitStack(S);if(T==NULL){cout<<" 树为空"<<endl;}while(T!=NULL || !IsEmpty(S)){if(T!=NULL){Push(S,T); T=T->lchild;}else{Pop(S,T);cout<<T->key<<" "T=T->rchild;}// 后序遍历void h_print(Tree T){Stack S; InitStack(S);Tree f=NULL;if(T==NULL){cout<<" 树为空"<<endl;} while(T!=NULL || !IsEmpty(S)){ while(T!=NULL) {Push(S,T);T=T->lchild;} getTop(S,T); if(T->rchild==NULL || T->rchild==f) {cout<<T->key<<" "; Pop(S,f); T=NULL;} else{T=T->rchild;}}}// 二叉树的深度int TreeDepth(Tree T) {int left,right,max; if(T!=NULL) {left=TreeDepth(T->lchild); right=TreeDepth(T->rchild);max=left>right?left:right; return max+1;}else{return ERROR;}}// 竖向输出// 树状输出二叉树void PrintTree(Tree T,int layer){int k;if(T==NULL)return ;PrintTree(T->rchild,layer+1);for(k=0;k<layer;k++)cout<<" ";cout<<T->key<<"\n";PrintTree(T->lchild,layer+1);}void main(){int key;int h;Tree tree;InitTree(tree); tree=CreatTree(tree);h=TreeDepth(tree);cout<<" 树状输出为:"<<endl;PrintTree(tree,h);if(!tree){}cout<<"\n\n ----------------------------------------------------- \n"<<endl;//int key; char select; cin>>select;while(select!='o'){switch(select){case 'o':exit(0);break;case 'a':if(!tree){cout<<" 树以为空,请重新选择操作 !"<<endl; cin>>select;}else{cout<<" 请输入要删除的元素 "<<endl;cin>>key;DeleteData(tree,key);cout<<" 树状输出为: "<<endl; PrintTree(tree,h);break;case 'b':cout<<" 请输入要插入的元素 "<<endl;exit(-1);cout<<"\n\n --------------------------------- \n"<<endl; 请输入你要选择的操cout<<"a. 删除二叉树中的元素cout<<"c. 先根遍历二叉树d. cout<<"e. 后根遍历二叉树o. b. 向二叉树中添加元素 "<<endl; 中根遍历二叉树 "<<endl; 退出操作 "<<endl;cin>>key;InsertBST(tree,key);cout<<" 树状输出为:"<<endl;PrintTree(tree,h);break;case 'c':cout<<" 先根遍历结果为:"<<endl; x_print(tree);cout<<endl;break;case 'd':cout<<" 中根遍历结果为:"<<endl;z_print(tree);cout<<endl;break;case 'e':cout<<" 后根遍历结果为:"<<endl;h_print(tree);cout<<endl;break;default:cout<<" 输入错误"<<endl;exit(-1);break;cout<<" -------------- 请输入你要选择的操作------------------- "<<endl;cout<<"a. 删除二叉树中的元素 b. 向二叉树中添加元素"<<endl; cout<<"c. 先根遍历二叉树 d. 中根遍历二叉树"<<endl; cout<<"e. 后根遍历二叉树o. 退出操作"<<endl;cout<<" ------------------------------------------------------- "<<endl;cin>>select;}}四、实验结果和数据处理I * D:\vc++∖c++\MSDev98\MyProject5\shujujiegou\Debug\shujujiegou.exe请输入你要选择的操作 -------------请输入要删除的元素22树状输岀为J88803932请输入要插入的兀素50树状输岀为:8880504?453932先根遍历结果为:45 32 39 49 80 50 88中根遍历结果为’32 39 45 49 50 80 88乩删除二叉树中的元素 ≡ C-TE e •后素 元一中二H 的二矍 择向龟 诜匚d .O . 要 你 ⅞I J I U l n 中叉叉 一树二二 一叉一中二 H 的二番 择向暑 ⅛u- ■ ■ ■ ⅛ b d □ -Γ的≡≡ -中叉叉 一树二二 一叉历历一二鬻 一除脣 Ace 一1芫 _加树 一添叉 一中二 fs 硕二番WS is;O. 『的 -中叉叉 一树二二 一 E<β 历 一二遍遍 一输入数据同选择操作结果如上图所示操作现象:输入操作的时候如果输入的不是数值(比如字母)就会出现插入操作错误的提示,然后异常退出操作;或者当输入的关键字已在树中存在,也会提示“重复输入”然后异常退出(这点存在不足,应该修改为提示之后重新输入操作)删除现象:如果要删除的关键字不存在则会提示不存在该关键字然后重新输入,如果树为空则会提示树为空并重新选择操作遍历现象:如果树为空,则不会退出操作,而是提示“树为空” 。
平衡二叉排序树实验报告
s.pop()//出栈
s.empty()//判断栈是否为空,是空时返回TRUE
s.top()//返回栈顶元素
q.push(SElemType e)//入队列
q.pop()//出队列
q.empty()//判断队列是否为空,是空时返回TRUE
q.front()//返回队头元素
T->data=e;
T->lchild=T->rchild=NULL;
T->bf=EH;
taller=true;
}
else{
if(e==T->data){
taller=false;
return 0;
}
if(e<T->data){
if(!InsertAVL(T->lchild,e,taller)) return 0;
p->rchild=rc->lchild;
rc->lchild=p;
p=rc;
}
void Left_Balance(BSTree &T){ //插入结点时向左平衡
BSTree lc,rd;
lc=T->lchild;
switch(lc->bf){
case LH:T->bf=lc->bf=EH;R_Rotate(T);break;
if(Visit(T->data))
if(PreOrderTraverse(T->lchild,Visit))
if(PreOrderTraverse(T->rchild,Visit)) return OK;
return ERROR;
二叉树实验报告总结(共10篇)
二叉树实验报告总结(共10篇)二叉树实验报告实验报告课程名称算法与数据结构专业学号姓名实验日期算法与数据结构实验报告一、实验目的1.了解二叉树的结构特点及有关概念,掌握二叉树建立的基本算法2.了解二叉树遍历的概念,掌握遍历二叉的算法3.进一步掌握树的结构及非线性特点,递归特点和动态性。
二、实验内容二叉树的实现和运算三、实验要求1.用C++/C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
3.分析算法,并简要给出算法设计小结和心得。
四、算法步骤用户以三元组形式输入二叉树的结点元素及其位置关系,建立二叉树,并打印输出该二叉树。
用户输入选择结点,程序调用BiTNode* Find Node(char tag, BiTNode* node)函数,返回子树的根结点,然后调用BiTreeDepth(BiTree T)函数,求出子树的深度,并输出该值。
3.用户可以选择是否继续执行程序,若继续,则输入1,否则输入0,结束程序。
五、主程序代码:int main(void){BiTree T;TElemType e1;char node; // node为用户选择输入的结点//int b,choose; // b为以选定结点为子树的深度,choose为实现多次选择输入的标志//BiTNode* a; // a为选定结点为子树的根结点//choose=1; // 多次选择的标志,当choose为1时运行程序,为0时结束程序// InitBiTree(T);printf(构造空二叉树后,树空否?%d(1:是0:否), 树的深度=%d\n,BiTreeEmpty(T),BiTreeDepth(T));e1 = Root(T);if(e1 != Nil)#ifdef CHARprintf(二叉树的根为: %c\n,e1);#endif#ifdef INTprintf(二叉树的根为: %d\n,e1);#endifelseprintf(树空,无根\n); //三元组构建二叉树striile(x!=end){AddNode(T, x[0], x[1], x[2]);GetUserWord(x);} //输出树PrintTreeLevel( T );//以三元组形式输入任意二叉树(以大写字母表示结点),求以任意一选定结点为子树的深度。
数据结构实验报告-二叉排序树的插入和检索
二叉排序树的插入和检索一、实验目的(对应的中级实验的实验目的)二叉排序树的插入和检索(1)实现二叉排序树的检索,若成功,记录检索的位置信息,若不成功,记录父结点的位置信息。
(2)调用检索算法实现插入,并输出插入后的二叉排序树。
(3)实现删除算法,删除后仍然满足二叉排序树的定义,并输出删除后的结果。
要求:用链式存储实现字典结构。
提示:对二叉排序树进行中根序遍历时,获得的是排序序列。
算法思想(1)创建二叉排序树算法:如果任一结点的左子树非空,则左子树中的所有结点的关键码都小于根结点的关键码;如果任一结点的右子树非空,则右子树中的所有结点的关键码都大于根结点的关键码。
(2)二叉排序树的检索二叉排序树的检索时,若成功,记录检索的位置信息(显示检索成功的信息),若不成功,记录父结点的位置信息(显示检索不成功的信息)。
(3)二叉排序树的插入插入后的二叉树仍满足二叉排序树的定义,插入新结点的方法:1.如果二叉排序树为空,则新结点作为根结点。
2.如果二叉排序树非空,则将新结点的关键码与根结点的关键码比较,若相等表示该结点已在二叉排序树中;若小于根结点的关键码,则将新结点插入到根结点的左子树中;否则,插入到右子树中。
3.子树中的插入过程和树中的插入过程相同,如此进行下去,直到找到该结点,或者直到左或右子树非空二叉树,新结点插入成为叶子结点为止。
(4)二叉排序树的删除删除结点后的二叉树仍满足二叉排序树的定义;第一种方法:1.如果被删除结点p没有左子树,则用p的右子女代替p即可;2.否则,在p的左子树中,找出关键码最大的一个结点r (r 处于p的左子树中最右下角的位置,r一定无右子女),将r的右指针指向p的右子女,用p的左子女代替p结点。
第二种方法:1.如果被删除结点p没有左子树,则用p的右子女代替p即可;2.否则,在p的左子树中,找出关键码最大的一个结点r,用结点r代替被删除的结点p,p原来的左右子女,并且用原来r的左子女代替原来的结点r。
二叉排序树实验报告
数据结构实验报告实验名称:______ 二叉排序树____________ 学生:______________卅级:______________卅序号:_____________学号:___________ Eli: _______1.实验耍求根据二叉排序购的抽象数18类璽的定义,便用二叉飪表实现一f二叉ft If Bk 二叉Ml序树的基本功能:1 •二叉排序射的建立2•二叉排序射的査找3•二叉排序粉的捕人4•二叉排序粉的H除5•二叉排序树的搏毁6•其他:自定义操作编写测试main()函数测试二叉排序鞫的正彌性2.程序分析2.1存储结构二叉捷表2.2程序流程(或程序结构、或类关系图等表明程序构成的容,一般为流程图等)2.2.1. S 程2.1关建算法分析査找BiNode* Search(BiNode* R,int key){if(R==NULL) return NULL;if(R->data==key) return R;if(R->data<key) return Search(R->rch,key);if(R->data>key) return Search(R->lch,key);K除void Delete(BiNode* &R){BiNode* q=new BiNode; BiNode *s=new BiNode; if(R->lch=NULL){ q=R; R=R->rch;delete q;}else if(R->rch==NULL){q=R;R=R->lch; delete q;Ielse!q=R;s=R->lch;while(s->rch!=NULL) {q=s; s=s->rch;}R->data=s->data;if(q!=R)q->rch=s->lch;elseR->lch=s->lch; delete s;void Deletedata(BiNode* &R, int key){if(R==NULL) return; if(R->data=key) Delete(R);else if(R->data>key) Deletedata(R->lch,key);else Deletedata(R->rch?key);首先先要定位到更剧除的节贞,不飾递归调用deletedata越个函数,找绡数值与需要剧除节点的数値相等的节点时,调用deletes t函数。
二叉排序树实验报告
二叉排序树实验报告二叉排序树实验报告一、引言二叉排序树,也被称为二叉搜索树,是一种常见的数据结构,它具有快速的查找和插入操作的特点。
在本次实验中,我们将探索二叉排序树的原理和实现,并通过实际操作来验证其性能和效果。
二、实验目的本次实验的目的是通过实际操作,深入理解二叉排序树的原理和实现,并通过对比不同操作的时间复杂度,评估其性能和效果。
三、实验过程1. 实验环境的搭建在开始实验之前,我们需要搭建一个合适的实验环境。
我们可以选择使用C++或者其他编程语言来实现二叉排序树。
在本次实验中,我们选择使用C++来实现。
2. 二叉排序树的实现首先,我们需要定义一个二叉排序树的数据结构。
这个数据结构包含一个根节点,每个节点包含一个值和两个指针,分别指向左子树和右子树。
通过递归的方式,我们可以实现二叉排序树的插入、删除和查找操作。
3. 实验数据的准备为了验证二叉排序树的性能和效果,我们需要准备一组实验数据。
这组数据可以是随机生成的整数,也可以是具有特定规律的数据。
我们可以选择不同规模的数据集来进行实验,以评估二叉排序树在不同情况下的表现。
4. 实验操作的执行通过实验数据的准备,我们可以开始执行实验操作。
首先,我们将数据依次插入到二叉排序树中,并记录下插入操作的时间。
然后,我们可以执行查找操作,查找树中是否包含某个特定的值,并记录下查找操作的时间。
最后,我们可以执行删除操作,删除树中的某个节点,并记录下删除操作的时间。
5. 实验结果的分析通过实验操作的执行,我们可以得到一组实验结果。
我们可以通过对比不同操作的时间复杂度,来评估二叉排序树的性能和效果。
同时,我们还可以观察实验结果中树的结构,以验证二叉排序树的正确性。
四、实验结果与讨论通过实验操作的执行,我们得到了一组实验结果。
我们可以观察到,随着数据规模的增加,插入、查找和删除操作的时间逐渐增加。
这是因为二叉排序树的操作时间复杂度与树的高度相关,当树的高度增加时,操作的时间复杂度也会增加。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
二叉排序树的实现一、实验内容与要求1)实现二叉排序树,包括生成、插入,删除;2)对二叉排序树进行先根、中根、和后根非递归遍历;3)每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。
二、实验方案1.选择链表的方式来构造节点,存储二叉排序树的节点。
//树的结构struct BSTNode{//定义左右孩子指针struct BSTNode *lchild,*rchild;//节点的关键字TElemType key;};int depth=0;//定义一个 struct BSTNode 类型的指针typedef BSTNode *Tree;2.对树的操作有如下方法:// 创建二叉排序树Tree CreatTree(Tree T);//二叉树的深度,返回一个int值为该树的深度int TreeDepth(Tree T)//树状输出二叉树,竖向输出void PrintTree(Tree T , int layer);//查找关键字,如果关键字存在则返回所在节点的父节点,如果关键字不存在则返回叶子所在的节点Status SearchBST(Tree T , TElemType key , Tree f,Tree &p);//向树中插入节点Status InsertBST(Tree &T , TElemType e);//删除节点Status Delete(Tree &T);//删除指定节点,调用Delete(Tree &T)方法Status DeleteData(Tree &T , TElemType key);//非递归先序遍历void x_print(Tree T);//非递归中序遍历Void z_print(Tree T );//非递归后序遍历void h_print(Tree T);3.对二叉排序树非递归先根、中根、后根遍历,采用栈来存储一次遍历过的节点的形式来辅助实现//自定义类型以 SElemType作为栈中指针返回的值的类型//也就是要返回一个节点的指针typedef Tree SElemType;//栈的结构struct Stack{//栈底指针SElemType *base;//栈顶指针SElemType *top;//栈的容量int stacksize;};4.栈的操作方法://创建一个空栈Status InitStack(Stack &S);//获取栈顶元素并删除栈中该位置的元素SElemType Pop(Stack &S,SElemType &elem)//获取栈顶元素返回栈顶元素不对栈做任何修改SElemType getTop(Stack S,SElemType &elem)//删除栈顶元素Status DeleteTop(Stack &S)//往栈中压入数据Status Push(Stack &S,SElemType elem)//判断栈是否为空Status IsEmpty(Stack S)三、代码实现#include <iostream>#include <math.h>using namespace std;//定义宏#define OK 1#define ERROR 0#define STACK_INIT_SIZE 10#define STACK_INCREMENT 2//定义宏分别为栈的初始容量和栈的增加容量#define STACK_INIT_SIZE 10#define STACK_INCREMENT 2typedef int TElemType;//树的结构struct BSTNode{//定义左右孩子指针struct BSTNode *lchild,*rchild;//节点的关键字TElemType key;};int depth=0;//定义一个 struct BSTNode 类型的指针typedef BSTNode *Tree;//自定义类型以 SElemType作为栈中指针返回的值的类型//也就是要返回一个节点的指针typedef Tree SElemType;//栈的结构struct Stack{//栈底指针SElemType *base;//栈顶指针SElemType *top;//栈的容量int stacksize;};//自定义类型typedef int Status;//创建一个空栈Status InitStack(Stack &S){//给栈指针分配空间S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));//如果分配空间失败则退出if(!S.base)exit(OVERFLOW);//栈底、栈顶指针相等表示栈为空//S.base=S.top;//此句代码若以如上句格式则在执行时会出现内存非法访问的错误S.top=S.base;//初始化栈的容量S.stacksize=STACK_INIT_SIZE;return OK;}//获取栈顶元素并删除栈中该位置的元素SElemType Pop(Stack &S,SElemType &elem){if(S.top==S.base){cout<<"gai zhan yi jing wei kong "<<endl;return ERROR;}else{elem=*--S.top;}return elem;}//获取栈顶元素返回栈顶元素不对栈做任何修改SElemType getTop(Stack S,SElemType &elem){//如果为空栈则返回ERRORif(S.base==S.top){cout<<"gai zhan yi jing wei kong"<<endl;return ERROR;}//如果栈不为空则返回栈顶元素else{elem=*(S.top-1);}return elem;}//删除栈顶元素Status DeleteTop(Stack &S){//判断栈是否为空if(S.base==S.top){cout<<"gai zhan yi jing wei kong "<<endl;return ERROR;}//如果栈不为空则删除栈顶元素else{--S.top;}return OK;}//往栈中压入数据Status Push(Stack &S,SElemType elem){//如果栈的容量超过初始化容量则增加栈的容量if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(SElemType));if(!S.base)exit(OVERFLOW);S.top=S.base+S.stacksize;S.stacksize+=STACK_INCREMENT;}//添加数据*S.top++=elem;return OK;}//判断栈是否为空Status IsEmpty(Stack S){if(S.base==S.top)return OK;elsereturn ERROR;}/////////////////////////////////////////////////////////////////// ///////////以下的代码主要是对树的操作///////////////////////////// /////////////////////////////////////////////////////////////////////创建空树Status InitTree(Tree &T){T=NULL;return OK;}//查找关键字//如果关键字存在则返回所在节点的父节点//如果关键字不存在则返回叶子所在的节点Status SearchBST(Tree T,TElemType key,Tree f,Tree &p) {if(!T){p=f;return ERROR;}else if(T->key==key){p=T;return OK;}else if(T->key>key)return SearchBST(T->lchild,key,T,p);else if(T->key<key)return SearchBST(T->rchild,key,T,p);}//向树中插入节点Status InsertBST(Tree &T,TElemType e){Tree p;if(!SearchBST(T,e,NULL,p)){Tree s=(Tree)malloc(sizeof(BSTNode));s->key=e;s->lchild=s->rchild=NULL;if(!p){T=s;}else if(p->key>e){p->lchild=s;}else if(p->key<e){p->rchild=s;}}elsereturn ERROR;}// 创建二叉排序树Tree CreatTree(Tree T){TElemType elem;cout<<"请输入数据,以0结束输入操作"<<endl;cin>>elem;while(elem!=0 && elem>0){int k= InsertBST(T,elem);if(k){cout<<"请输入数据,以0结束输入操作"<<endl;cin>>elem;}else{cout<<"插入错误或存在重复元素"<<endl;//异常退出return ERROR;}}return T;}//删除节点Status Delete(Tree &T){Tree p,q;if(T->lchild!=NULL && T->rchild!=NULL){p=T;q=T->lchild;T=q;while(q->rchild!=NULL){q=q->rchild;}q->rchild=p->rchild;free(p);return OK;}if(T->rchild==NULL && T->lchild!=NULL){p=T;T=T->lchild;free(p);return OK;}else if(T->lchild==NULL && T->rchild!=NULL) {p=T;T=T->rchild;free(p);return OK;}else if(T->rchild==NULL && T->lchild==NULL){T=NULL;free(T);return OK;}}//删除指定节点Status DeleteData(Tree &T,TElemType key){if(!T){cout<<"找不到要删除的元素,请重新选择!"<<endl;return ERROR;}if(T->key==key){Delete(T);}else if(T->key>key)DeleteData(T->lchild,key);else if(T->key<key)DeleteData(T->rchild,key);return OK;}//先序遍历void x_print(Tree T){//Tree f;Stack S;InitStack(S);if(T==NULL){cout<<"树为空"<<endl;}while(T!=NULL || !IsEmpty(S)){if(T!=NULL){cout<<T->key<<" ";Push(S,T);T=T->lchild;}else{Pop(S,T);T=T->rchild;}}}//z中序遍历void z_print(Tree T ){// Tree f;Stack S;InitStack(S);if(T==NULL){cout<<"树为空"<<endl;}while(T!=NULL || !IsEmpty(S)){if(T!=NULL){Push(S,T);T=T->lchild;}else{Pop(S,T);cout<<T->key<<" ";T=T->rchild;}}}//后序遍历void h_print(Tree T){Stack S;InitStack(S);Tree f=NULL;if(T==NULL){cout<<"树为空"<<endl;}while(T!=NULL || !IsEmpty(S)){while(T!=NULL){Push(S,T);T=T->lchild;}getTop(S,T);if(T->rchild==NULL || T->rchild==f){cout<<T->key<<" ";Pop(S,f);T=NULL;}else{T=T->rchild;}}}//二叉树的深度int TreeDepth(Tree T){int left,right,max;if(T!=NULL){left=TreeDepth(T->lchild);right=TreeDepth(T->rchild);max=left>right?left:right;return max+1;}else{return ERROR;}}//竖向输出//树状输出二叉树void PrintTree(Tree T,int layer){int k;if(T==NULL)return ;PrintTree(T->rchild,layer+1);for(k=0;k<layer;k++)cout<<" ";cout<<T->key<<"\n";PrintTree(T->lchild,layer+1);}void main(){int key;int h;Tree tree;InitTree(tree);tree=CreatTree(tree);h=TreeDepth(tree);cout<<"树状输出为:"<<endl;PrintTree(tree,h);if(!tree){exit(-1);}cout<<"\n\n---------------请输入你要选择的操作--------------------\n"<<endl;cout<<"a.删除二叉树中的元素 b.向二叉树中添加元素"<<endl;cout<<"c.先根遍历二叉树 d.中根遍历二叉树 "<<endl;cout<<"e.后根遍历二叉树 o.退出操作 "<<endl;cout<<"\n\n------------------------------------------------------\n"<<endl;//int key;char select;cin>>select;while(select!='o'){switch(select){case 'o':exit(0);break;case 'a':if(!tree){cout<<"树以为空,请重新选择操作!"<<endl;cin>>select;}else{cout<<"请输入要删除的元素"<<endl;cin>>key;DeleteData(tree,key);cout<<"树状输出为:"<<endl;PrintTree(tree,h);}break;case 'b':cout<<"请输入要插入的元素"<<endl;cin>>key;InsertBST(tree,key);cout<<"树状输出为:"<<endl;PrintTree(tree,h);break;case 'c':cout<<"先根遍历结果为:"<<endl;x_print(tree);cout<<endl;break;case 'd':cout<<"中根遍历结果为:"<<endl;z_print(tree);cout<<endl;break;case 'e':cout<<"后根遍历结果为:"<<endl;h_print(tree);cout<<endl;break;default:cout<<"输入错误"<<endl;exit(-1);break;}cout<<"---------------请输入你要选择的操作--------------------"<<endl;cout<<"a.删除二叉树中的元素 b.向二叉树中添加元素"<<endl;cout<<"c.先根遍历二叉树 d.中根遍历二叉树 "<<endl;cout<<"e.后根遍历二叉树 o.退出操作 "<<endl;cout<<"--------------------------------------------------------"<<endl;cin>>select;}}四、实验结果和数据处理输入数据同选择操作结果如上图所示操作现象:输入操作的时候如果输入的不是数值(比如字母)就会出现插入操作错误的提示,然后异常退出操作;或者当输入的关键字已在树中存在,也会提示“重复输入”然后异常退出(这点存在不足,应该修改为提示之后重新输入操作)删除现象:如果要删除的关键字不存在则会提示不存在该关键字然后重新输入,如果树为空则会提示树为空并重新选择操作遍历现象:如果树为空,则不会退出操作,而是提示“树为空”。