二叉排序树的查找实验报告

合集下载

数据结构试验报告二叉排序树的操作

数据结构实验报告班级：信息与计算科学专业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.详细设计实现概要设计中定义的所有数据类型，对每个操作给出伪码算法。

数据结构二叉排序树实验报告

实验报告课程名：数据结构（C语言版）实验名：二叉排序树姓名：班级：学号：撰写时间：2014.12.18一实验目的与要求1.掌握二叉排序树上进行插入和删除的操作2.利用 C 语言实现该操作二实验内容•对于一个线形表, 利用不断插入的方法, 建立起一株二叉排序树•从该二叉排序树中删除一个叶子节点, 一个只有一个子树的非叶子节，一个有两个子树的非叶子节点。

三实验结果与分析#include<stdio.h>#include<stdlib.h>//二叉查找树结点描述typedef int KeyType;typedef struct Node{KeyType key; //关键字struct Node * left; //左孩子指针struct Node * right; //右孩子指针struct Node * parent; //指向父节点指针}Node,*PNode;//往二叉查找树中插入结点//插入的话，可能要改变根结点的地址，所以传的是二级指针void inseart(PNode * root,KeyType key){//初始化插入结点PNode p=(PNode)malloc(sizeof(Node));p->key=key;p->left=p->right=p->parent=NULL;//空树时，直接作为根结点if((*root)==NULL){*root=p;return;}//插入到当前结点（*root）的左孩子if((*root)->left == NULL && (*root)->key > key){ p->parent=(*root);(*root)->left=p;return;}//插入到当前结点（*root）的右孩子if((*root)->right == NULL && (*root)->key < key){ p->parent=(*root);(*root)->right=p;return;}if((*root)->key > key)inseart(&(*root)->left,key);else if((*root)->key < key)inseart(&(*root)->right,key);elsereturn;}//查找元素,找到返回关键字的结点指针，没找到返回NULL PNode search(PNode root,KeyType key){if(root == NULL)return NULL;if(key > root->key) //查找右子树return search(root->right,key);else if(key < root->key) //查找左子树return search(root->left,key);elsereturn root;//查找最小关键字,空树时返回NULLPNode searchMin(PNode root){if(root == NULL)return NULL;if(root->left == NULL)return root;else //一直往左孩子找，直到没有左孩子的结点 return searchMin(root->left);}//查找最大关键字,空树时返回NULLPNode searchMax(PNode root){if(root == NULL)return NULL;if(root->right == NULL)return root;else //一直往右孩子找，直到没有右孩子的结点 return searchMax(root->right);//查找某个结点的前驱PNode searchPredecessor(PNode p){//空树if(p==NULL)return p;//有左子树、左子树中最大的那个if(p->left)return searchMax(p->left);//无左子树,查找某个结点的右子树遍历完了 else{if(p->parent == NULL)return NULL;//向上寻找前驱while(p){if(p->parent->right == p)break;p=p->parent;}return p->parent;}}//查找某个结点的后继PNode searchSuccessor(PNode p){//空树if(p==NULL)return p;//有右子树、右子树中最小的那个if(p->right)return searchMin(p->right);//无右子树,查找某个结点的左子树遍历完了 else{if(p->parent == NULL)return NULL;//向上寻找后继while(p){if(p->parent->left == p)break;p=p->parent;}return p->parent;}}//根据关键字删除某个结点,删除成功返回1,否则返回0//如果把根结点删掉，那么要改变根结点的地址，所以传二级指针int deleteNode(PNode* root,KeyType key){PNode q;//查找到要删除的结点PNode p=search(*root,key);KeyType temp; //暂存后继结点的值//没查到此关键字if(!p)return 0;//1.被删结点是叶子结点，直接删除if(p->left == NULL && p->right == NULL){//只有一个元素，删完之后变成一颗空树if(p->parent == NULL){free(p);(*root)=NULL;}else{//删除的结点是父节点的左孩子if(p->parent->left == p)p->parent->left=NULL;else //删除的结点是父节点的右孩子 p->parent->right=NULL;free(p);}}//2.被删结点只有左子树else if(p->left && !(p->right)){p->left->parent=p->parent;//如果删除是父结点，要改变父节点指针 if(p->parent == NULL)*root=p->left;//删除的结点是父节点的左孩子else if(p->parent->left == p)p->parent->left=p->left;else //删除的结点是父节点的右孩子p->parent->right=p->left;free(p);}//3.被删结点只有右孩子else if(p->right && !(p->left)){p->right->parent=p->parent;//如果删除是父结点，要改变父节点指针if(p->parent == NULL)*root=p->right;//删除的结点是父节点的左孩子else if(p->parent->left == p)p->parent->left=p->right;else //删除的结点是父节点的右孩子p->parent->right=p->right;free(p);}//4.被删除的结点既有左孩子，又有右孩子//该结点的后继结点肯定无左子树(参考上面查找后继结点函数) //删掉后继结点,后继结点的值代替该结点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：二叉树排序实验结果。

实验报告：二叉树

实验报告：二叉树第一篇：实验报告：二叉树实验报告二叉树一实验目的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 姓名：朱报龙成绩：_________实验七二叉树操作验证一、实验目的⑴ 掌握二叉树的逻辑结构；⑵ 掌握二叉树的二叉链表存储结构；⑶ 掌握基于二叉链表存储的二叉树的遍历操作的实现。

实验六折半和二叉排序树查找实验

软件学院数据结构实验报告2012 ～2013 学年第一学期 2011 级水利信息管理专业班级：学号：姓名：实验六查找算法实验一、实验目的1、掌握静态查找表的查找算法2、掌握二叉排序树的查找算法3、掌握哈希函数的构造和哈希表的查找4、了解查找表的广泛应用二、实验内容1、有序表的查找1.1 数据结构的设计有序表的存储结构（数组表示)#define Max 20int a[Max] = {05,13,19,21,37,56,64,75,80,88,92}1.2 基本思想：折半查找算法在有序表中，取中间的记录作为比较对象，如果要查找记录的关键字等于中间记录的关键字，则查找成功；若要查找记录的关键字小于中间记录的关键字，则在中间记录的左半区继续查找；若要查找记录的关键字大于中间记录的关键字，则在中间记录的右半区继续查找。

不断重复上述查找过程，直到查找成功，或有序表中没有所要查找的记录，查找失败。

例：输入：查找记录的关键字 k = 13，k =37，k =99输出：k=13，查找成功；k=37，查找成功；k=99，查找不成功1.3 实验步骤：源程序：1.4 运行结果：2、二叉排序树的查找2.1 数据结构的设计二叉链表的存储结构表示：typedef int datatype;struct bi_search_tree{datatype key;struct bi_search_tree *left, *right;}bst_tree;2.2 基本思路先将输入的数据记录序列通过二叉排序树的插入算法建立一个二叉排序树，然后在二叉排序树中查找某个给定的关键字，返回查找成功或者不成功的结果输入：（1）数据记录序列{37,56,05,13,19,21, 64, 88, 75,80,92}建立二叉排序树，（2）查找记录的关键字 k = 13，k =37，k =99输出：k=13，查找成功；k=37，查找成功；k=99，查找不成功2.3 实验步骤：主要函数声明：主函数代码：2.4 运行结果：三、问题讨论1、折半查找有哪些特点？2、二叉排序树有那些特点？四、实验心得实验源码：（折半查找）#include <stdio.h>#define LENGTH 20void Search(int *fp,int data,int length);void main(){int count,i,choise;int arr[LENGTH];printf("请输入你的数据的个数:\n");scanf("%d",&count);printf("请输入%d个有序的数据\n",count);for(i=0;i<count;i++){scanf("%d",&arr[i]);}printf("请输入你要查找的数据:\n");scanf("%d",&choise);Search(arr,choise,count);}void Search(int *fp,int data,int length){int i=0;int low,high,middle;low=0; high=length;while (low<=high){middle=(low+high)/2;i++;if(fp[middle]<data){low=middle+1;}else if(fp[middle]>data){high=middle-1;}else{printf("经过%d次查找，查找到数据:%d.\n",i,data);return;}}printf("经过%d次查找，未能查找到数据:%d.\n",i,data);}二叉排序树：#include <stdio.h>#include <stdlib.h>#include <string.h>#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)< (b))#define LQ(a,b) ((a)<=(b))#define TRUE 1#define FALSE 0#define OVERFLOW -2typedef int KeyType;typedef int Status;typedef struct{KeyType key; /*关键字域*/}SElemType;typedef struct BitNode{SElemType data; /*存储空间基址,建表时按实际长度分配，0号单元留空*/ struct BitNode *lchild,*rchild;}BitNode,* BiTree;/*二叉排序树的插入*/Status InsertBST(BiTree T, KeyType key){BiTree s;if(!T){s=(BiTree)malloc(sizeof(BitNode));s->data.key=key;s->lchild=s->rchild=NULL;T=s;}else if LT(key,T->data.key)InsertBST(T->lchild,key);else InsertBST(T->rchild,key);return TRUE;}/*创建二叉排序树*/void CreateBST(BiTree T){KeyType key;T=NULL;scanf("%d",&key);while(key!=0){InsertBST(T,key);scanf("%d",&key);}}/*中序遍历*/void InOrderTraverse(BiTree T){if(T){InOrderTraverse(T->lchild);printf("%4d",T->data.key);InOrderTraverse(T->rchild);}}/*打印二叉树*/Status PrintTree(BiTree T,int n){int i=0;if(T == NULL)return FALSE;PrintTree(T->rchild,n+1);for(i=0;i<n;i++)printf(" ");printf("%d\n",T->data.key);PrintTree(T->lchild,n+1);return TRUE;}/*二叉排序树的查找*/BiTree SearchBST(BiTree T,KeyType key){if(!T){printf("Can not find!!\n");return T;}else if EQ(key,T->data.key){return T;}else if LT(key,T->data.key) return SearchBST(T->lchild,key); else return SearchBST(T->rchild,key);}/*二叉排序树的删除*/Status Delete(BiTree p){BiTree q,s;if(!p->rchild){q=p;p=p->lchild;free(q);}else if(!p->lchild){q=p;p=p->rchild;free(q);}else{q=p;s=p->lchild;while(s->rchild){q=s;s=s->rchild;}p->data=s->data;if(q!=p) q->rchild=s->lchild;else q->lchild=s->lchild;// delete s;}return TRUE;}Status DeleteBST(BiTree T,KeyType key){if(!T)return FALSE;else{if (EQ(key,T->data.key))return Delete(T);elseif(LT(key,T->data.key))return DeleteBST(T->lchild,key);else return DeleteBST(T->rchild,key);}}void main() {BiTree b1,b2;KeyType key;int t;begin:printf("1:创建二叉排序树\n");printf("2:打印排序树\n");printf("3:查找结点\n");printf("4:中序遍历\n");printf("5:插入结点\n");printf("6:删除结点\n");printf("0:退出\n");printf("请选择要进行的操作:");scanf("%d",&t);switch(t){case 1:printf("Input every key (0 to quit):");CreateBST(b1);PrintTree(b1,0);//排序树的结果打印出来goto begin;case 2:PrintTree(b1,0);goto begin;case 3:printf("Input the key to search:");scanf("%d",&key);if(key!=0){b2=SearchBST(b1,key);//把 key 为根的子树打印出来PrintTree(b2,0);printf("\nThe root is the key to search!!\n\n");}else printf("Can not find!!\n");goto begin;case 4:InOrderTraverse(b1);goto begin;case 5:printf("输入要插入的数据：");scanf("%d",&key);if(InsertBST(b1, key))printf("\n插入完毕！\n");else printf("插入失败\n");goto begin;case 6:printf("输入要删除的数据：");scanf("%d",&key);if(DeleteBST(b1, key))printf("\n删除完毕！\n");else printf("删除失败\n");goto begin;case 0: break;default: printf("输入错误\n");}}。

二叉排序树的实验报告

二叉排序树的实验报告二叉排序树的实验报告引言：二叉排序树（Binary Search Tree，简称BST）是一种常用的数据结构，它将数据按照一定的规则组织起来，便于快速的查找、插入和删除操作。

本次实验旨在深入了解二叉排序树的原理和实现，并通过实验验证其性能和效果。

一、实验背景二叉排序树是一种二叉树，其中每个节点的值大于其左子树的所有节点的值，小于其右子树的所有节点的值。

这种特性使得在二叉排序树中进行查找操作时，可以通过比较节点的值来确定查找的方向，从而提高查找效率。

二、实验目的1. 理解二叉排序树的基本原理和性质；2. 掌握二叉排序树的构建、插入和删除操作；3. 验证二叉排序树在查找、插入和删除等操作中的性能和效果。

三、实验过程1. 构建二叉排序树首先，我们需要构建一个空的二叉排序树。

在构建过程中，我们可以选择一个节点作为根节点，并将其他节点插入到树中。

插入节点时，根据节点的值与当前节点的值进行比较，如果小于当前节点的值，则将其插入到当前节点的左子树中；如果大于当前节点的值，则将其插入到当前节点的右子树中。

重复这个过程，直到所有节点都被插入到树中。

2. 插入节点在已有的二叉排序树中插入新的节点时，我们需要遵循一定的规则。

首先，从根节点开始，将新节点的值与当前节点的值进行比较。

如果小于当前节点的值，则将其插入到当前节点的左子树中；如果大于当前节点的值，则将其插入到当前节点的右子树中。

如果新节点的值与当前节点的值相等，则不进行插入操作。

3. 删除节点在二叉排序树中删除节点时，我们需要考虑不同的情况。

如果要删除的节点是叶子节点，即没有左右子树，我们可以直接删除该节点。

如果要删除的节点只有一个子树，我们可以将子树连接到要删除节点的父节点上。

如果要删除的节点有两个子树，我们可以选择将其右子树中的最小节点或左子树中的最大节点替代该节点，并删除相应的替代节点。

四、实验结果通过对二叉排序树的构建、插入和删除操作的实验，我们得到了以下结果：1. 二叉排序树可以高效地进行查找操作。

二叉排序树实验报告

深圳大学实验报告
课程名称：数据结构实验与课程设计
实验项目名称：二叉排序树实验
学院：计算机与软件学院
专业：
指导教师：
报告人：学号：班级： 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日内。

数据结构与算法实验报告二叉排序树

*p = f;
return FALSE;
}else if (key == T->data){
*p = T;
return TRUE;
}else if (key < T->data){ // 在左子树中继续查找
return SearchBST(T->lchild, key, T, p);
}else{ // 在右子树中鸡血查找
for (i = 0; i < 10; i++) { // 通过插入操作来构建二叉排序树
InsertBST(&T, a[i]);
}
printf("中序递归遍历二叉排序树：\n");
InOrderTraverse(T);
printf("\n\n");
DeleteBST(&T, 93);
printf("删除结点 93 后的结果为：\n");
InOrderTraverse(T);
printf("\n\n");
printf("插入 91 后的结果为：\n");
InsertBST(&T, 91);
InOrderTraverse(T);
printf("\n\n");
return 0;
}
实验心得：
通过本次实验，我理解了二叉排序树的概念，掌握实现算法。同时在二叉排序树的删除操作的代码编写时，让我明白了不同情况的不同处理方式，养成了更严谨的编写代码的思维方式。
free(s);
}
return TRUE;
}
int DeleteBST(BiTree * T, int key){

利用二叉排序树对一组数据排序并查找元素

《数据结构》实验报告◎实验题目: 利用二叉排序树对一组数据排序并查找元素◎实验目的：(1)熟悉二叉排序树的生成算法；(2)了解将排序二叉树转化为有序排列的方法；(3)学会在一组数据中查找元素。

◎实验内容：建立一组数据的二叉排序树，然后中序遍历，并查找待查找元素。

一、需求分析1．输入的形式和输入值的范围:本程序要求输入待排序数的个数，并逐个输入待排序数，最后输入待查找元素的值。

2．输出的形式:按从小到大的顺序输出排过序的数，并输出查找结果，如果存在，还需输出待查找数在已排序序列中的位置。

3．程序所能达到的功能:对确定个数的一组数实现递增排序，并查找待查找元素。

4．测试数据：待排序数个数:5;待排序数:12 43 23 54 8;已存在元素查找:23;不存在的元素查找:10二概要设计1.二叉排序树的生成模块:根据二叉排序树的定义，任一节点如果有左子树，其左子树各节点的数据必须小于该节点的数据；任一节点如果有右子树，其右子树各节点的数据必须等于或大于该节点的数据。

则可将第一个数据作为整个二叉排序树的根节点，以后的数据都从根节点起，由上而下逐层与原有节点的数据相比较，若较原节点数值小，则进而与其左孩子节点的数值比，否则与其右孩子节点数据比，直至找到一个节点相应的指针是空指针了，即将新结点插入此处作为终端节点。

2.已排序序列的输出与查找元素模块:根据排序二叉树的结构特点，只要对该二叉树进行中序遍历，即可按从小到大的顺序访问这些数据节点，再在访问这些节点的时候与待查找元素比较，如果找到，记下该数据位置，如果访问完了还没找到，则待查找元素不存在。

三详细设计1.定义结构体变量typedef struct node{int data;struct node *lchild;struct node *rchild;}Lnode,*Linklist;2.定义指针栈typedef struct{Linklist data[MAXSIZE];int top;}Seqstack;3.初始化栈函数void Initstack(Seqstack &s){s.top=-1;}4.判断栈空函数，如果栈空返回1，否则返回0int StackEmpty(Seqstack &s){if(s.top==-1)return 1;elsereturn 0;}5.入栈函数void push(Seqstack &s,Linklist x){s.top++;s.data[s.top]=x;}6.出栈函数Linklist pop(Seqstack &s){return s.data[s.top--];}7.二叉排序树的生成函数，具体算法为:(1)读取一个待排序数；(2)生成一个新节点，将读入数据赋给新节点；(3)若根节点为空，则另根节点等于该新节点，否则○1如果小于根节点，沿左链域比较；○2否则沿右链域比较；(4)直至到终端，插入该结点。

实验报告平衡二叉树

实习报告一、需求分析1、问题描述利用平衡二叉树实现一个动态查找表。

（1）实现动态查找表的三种基本功能：查找、插入和删除。

（2）初始时，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。

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

在查找时，如果查找的关键字不存在，则把其插入到平衡二叉树中。

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

（3）每次操作的关键字都要从文件中读取，并且关键字的集合限定为短整型数字{1，2，3······}，关键字出现的顺序没有限制，允许出现重复的关键字，并对其进行相应的提示。

（4）平衡二叉树的显示采用图形界面画出图形。

2、系统功能打开数据文件，用文件中的关键字来演示平衡二叉树操作的过程。

3、程序中执行的命令包括：（1）(L)oad from data file //在平衡的二叉树中插入关键字；（2）(A)ppend new record //在平衡的二叉树中查找关键字；（3）(U)pate special record //显示调整过的平衡二叉树；（4）(D)elete special record //删除平衡二叉树中的关键字；（5）(Q)uit //结束。

4、测试数据：平衡二叉树为：图 1 插入关键字10之前的平衡二叉树插入关键字：10；调整后：图 2 插入关键字10之后的平衡二叉树删除关键字：14；调整后：图 3 删除关键字14后的平衡二叉树查找关键字：11；输出：The data is here!图 3 查找关键字11后的平衡二叉树二、概要设计本次实验目的是为了实现动态查找表的三种基本功能：查找、插入和删除。

动态查找表可有不同的表示方法，在此次实验中主要是以平衡二叉树的结构来表示实现的，所以需要两个抽象数据类型：动态查找表和二叉树。

1、动态查找表的抽象数据类型定义为：ADT DynamicSearchTable{数据对象D ：D是具有相同特性的数据元素的集合。

二叉排序树的查找与性能分析

二叉排序树的查找与性能分析二叉排序树的查找与性能分析问题分析：本实验是通过建立一个二叉树，并通过输入报名号，查找出与此报名号对应的学生的其他信息，并通过查找的次数来分析此程序的性能，最后与做平衡二叉树的查找与性能分析的那组比较，分析。

设计思路：首先进行二叉链表的存储表示，将数据类型和基本操作定义好。

一．二叉排序树的查找二叉排序树的查找包含二叉排序树的建立，二叉排序树的插入，二叉树的遍历，二叉排序树的生成，以及二叉排序树的查找等部分。

1．二叉排序树的建立二叉数是每个结点至多只有两颗子树的树形结构即左子树和右子树，在二叉树的第i层上至多有2^(i-1)个结点（i≥1）。

而二叉排序树是动态的，中序遍历后，二叉排序树将是一个递增有序序列。

二叉排序树可以是一个空树，也可以是一个有如下性质的二叉树：（1）左子树非空，左子树上所有结点的值均小于根结点的值；（2）右子树非空，右子树上所有结点的值均大于根结点的值；（3）左右子树本身又各是一颗二叉排序树。

利用链式存储结构，由一个数据元素和分别指向左右结点的指针构成，即二叉链表。

首先可以按线序次序输入二叉树结点的值，如果是空指针（即NULL）则为空树，这样就可以生成根结点，再利用递归构造左子树和右子树。

并将关键字即学号插入二叉排序中;在建立时就可将二叉树中序遍历。

2．二叉排序树的插入在二叉排序树中插入新节点，要保证插入后的二叉树仍然符合二叉排序树的定义。

插入过程如下:若二叉排序树为空，则待插入结点s作为根结点插入到空树中；当非空时，将待插结点关键字s->key和树根关键字t->key进行比较，若s->keyt=t->key，则无需插入；若s->keykey，则插入到根的左子树；若s->key>t->key，则插入到根的右子树。

而子树的插入过程与树中的插入过程相同。

如此进行下去，知道把结点s作为新的树叶插入到二叉排序树中，或者直到发现已相同的关键字（即学号）结点为止。

对于二叉排序树的实现的实践成果报告

对于二叉排序树的实现的实践成果报告一、二叉树序数算法的内容二叉排序树的实现，用顺序和二叉链表作存储结构。

首先，以回车（’\n’）为输入结束标志，输入数列L，生成一棵二叉排序树T；然后，对二叉排序树T作中序遍历，输出结果；最后，输入元素x，查找二叉排序树T，若存在含x的结点，则删除该结点，并作中序遍历(执行操作2)；否则输出信息“无x”；二、算法流程1.用C++实现二叉排序树的源代码2.建立一个二叉树3.在一棵二叉排序树中插入一个数4.在一个二叉排序树查找一个数是否存在5.在一个二叉排序树删除一个给定的值6.显示一个二叉排序树7.删除一棵整二叉排序树8.进行对二叉树的基本操作三、算法的应用领域和作用1.基于二叉排序树的缓冲机制在污染源监控系统中的研究传统意义上的污染源在线自动监控系统的数据查询采用顺序查找法，由于其时间复杂度高，导致在数据量巨大的场合下效率低下。

本文研究与实现基于二叉排序树的数据缓冲机制的污染源在线自动监控系统，提高监测污染物的效率，降低查询时间复杂度。

树形目录的存储结构比线性表结构的组织形式更灵活，所以对于数据量大的信息通常采用树形结构存储。

污染物数据存储于关系数据库中，查询时需要频繁地访问数据库。

从数据库中获得一个数据项所需要的计算机指令数往往比从服务器中获得一个文件要大一到两个数量级，影响系统运行的整体性能。

在多数系统中对某一对象重复访问，通常将生成数据进行缓冲处理，有利于系统性能的提高。

2. 缓冲实例的产生2.1系统缓冲机制缓冲机制主要是基于被访问数据以减少网络传输、提高检索效率为目的。

动态的缓冲是客户端通过网络访问服务器动态生成的，广域网环境中客户端请求的响应时间与请求传输时间、协议处理时间、数据装载时间、数据传输时间、数据表示时间有关。

在这种环境中，缓冲主要是为了减少请求时间和数据的传输时间。

缓冲数据主要分为两部分，主要存储在服务器端。

数据对象的集合较为巨大，仅仅存放于硬盘上会直接影响访问速度。

树的查找实验报告

一、实验目的1. 理解树的概念及其在计算机科学中的应用。

2. 掌握几种常见树的查找方法，如二叉查找树、平衡树等。

3. 分析不同查找方法的效率，比较其优缺点。

4. 提高编程能力，巩固数据结构知识。

二、实验内容1. 二叉查找树（Binary Search Tree，BST）2. 平衡树（AVL树）3. 堆（Heap）三、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发环境：PyCharm四、实验步骤1. 创建二叉查找树```pythonclass TreeNode:def __init__(self, val):self.val = valself.left = Noneself.right = Nonedef insert(root, val):if root is None:return TreeNode(val)if val < root.val:root.left = insert(root.left, val) else:root.right = insert(root.right, val) return rootdef inorder_traversal(root):if root:inorder_traversal(root.left)print(root.val, end=' ')inorder_traversal(root.right)# 创建二叉查找树root = Nonevalues = [8, 3, 10, 1, 6, 14, 4, 7, 13]for value in values:root = insert(root, value)print("二叉查找树的中序遍历：")inorder_traversal(root)```2. 创建平衡树（AVL树）```pythonclass AVLNode:def __init__(self, val):self.val = valself.left = Noneself.right = Noneself.height = 1def get_height(node):if not node:return 0return node.heightdef get_balance(node):if not node:return 0return get_height(node.left) - get_height(node.right)def right_rotate(y):x = y.leftT2 = x.rightx.right = yy.left = T2y.height = 1 + max(get_height(y.left), get_height(y.right)) x.height = 1 + max(get_height(x.left), get_height(x.right)) return xdef left_rotate(x):y = x.rightT2 = y.lefty.left = xx.right = T2x.height = 1 + max(get_height(x.left), get_height(x.right))y.height = 1 + max(get_height(y.left), get_height(y.right))return ydef insert(root, val):if not root:return AVLNode(val)if val < root.val:root.left = insert(root.left, val)else:root.right = insert(root.right, val)root.height = 1 + max(get_height(root.left), get_height(root.right)) balance = get_balance(root)if balance > 1 and val < root.left.val:return right_rotate(root)if balance < -1 and val > root.right.val:return left_rotate(root)if balance > 1 and val > root.left.val:root.left = left_rotate(root.left)return right_rotate(root)if balance < -1 and val < root.right.val:root.right = right_rotate(root.right)return left_rotate(root)return root# 创建平衡树root = Nonevalues = [8, 3, 10, 1, 6, 14, 4, 7, 13]for value in values:root = insert(root, value)print("平衡树的中序遍历：")inorder_traversal(root)```3. 创建堆（Heap）```pythondef heapify(arr, n, i):largest = il = 2 i + 1r = 2 i + 2if l < n and arr[i] < arr[l]:largest = lif r < n and arr[largest] < arr[r]:largest = rif largest != i:arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest)def build_heap(arr):n = len(arr)for i in range(n // 2 - 1, -1, -1):heapify(arr, n, i)def extract_max(arr):n = len(arr)max_val = arr[0]arr[0] = arr[n - 1]n -= 1heapify(arr, n, 0)return max_val# 创建堆values = [8, 3, 10, 1, 6, 14, 4, 7, 13]heap = values.copy()build_heap(heap)print("堆的中序遍历：")inorder_traversal(heap)```五、实验结果与分析1. 二叉查找树：在插入过程中，树会保持有序，查找效率较高，但可能会出现不平衡的情况。

二叉排序树实验报告

二叉排序树的实现实验内容与要求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<β 历一二遍遍一输入数据同选择操作结果如上图所示操作现象：输入操作的时候如果输入的不是数值（比如字母）就会出现插入操作错误的提示，然后异常退出操作；或者当输入的关键字已在树中存在，也会提示“重复输入”然后异常退出（这点存在不足，应该修改为提示之后重新输入操作）删除现象：如果要删除的关键字不存在则会提示不存在该关键字然后重新输入，如果树为空则会提示树为空并重新选择操作遍历现象：如果树为空，则不会退出操作，而是提示“树为空” 。

检索树的实验报告

一、实验目的1. 理解检索树（也称为二叉搜索树）的基本概念和原理。

2. 掌握检索树的构建方法，包括插入、删除和查找操作。

3. 通过实验验证检索树在实际应用中的效率和效果。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发环境：PyCharm三、实验原理检索树是一种特殊的二叉树，它的特点是左子树上所有节点的值均小于它的根节点的值，右子树上所有节点的值均大于它的根节点的值。

通过这种特性，检索树可以快速地对数据进行插入、删除和查找操作。

四、实验内容1. 检索树的构建2. 检索树的插入操作3. 检索树的删除操作4. 检索树的查找操作5. 检索树的应用五、实验步骤1. 定义树节点类```pythonclass TreeNode:def __init__(self, key):self.left = Noneself.right = Noneself.val = key```2. 定义检索树类```pythonclass BinarySearchTree:def __init__(self):self.root = Nonedef insert(self, key):if self.root is None:self.root = TreeNode(key)else:self._insert(self.root, key)def _insert(self, node, key):if key < node.val:if node.left is None:node.left = TreeNode(key)else:self._insert(node.left, key) else:if node.right is None:node.right = TreeNode(key) else:self._insert(node.right, key)def delete(self, key):self.root = self._delete(self.root, key)def _delete(self, node, key):if node is None:return nodeif key < node.val:node.left = self._delete(node.left, key)elif key > node.val:node.right = self._delete(node.right, key)else:if node.left is None:return node.rightelif node.right is None:return node.leftmin_larger_node = self._find_min(node.right)node.val = min_larger_node.valnode.right = self._delete(node.right, min_larger_node.val) return nodedef _find_min(self, node):while node.left is not None:node = node.leftreturn nodedef search(self, key):return self._search(self.root, key)def _search(self, node, key):if node is None:return Falseif key == node.val:return Trueelif key < node.val:return self._search(node.left, key)else:return self._search(node.right, key)```3. 实验验证```pythonbst = BinarySearchTree()bst.insert(50)bst.insert(30)bst.insert(20)bst.insert(40)bst.insert(70)bst.insert(60)bst.insert(80)print("查找 30 的结果：", bst.search(30)) # 输出：Trueprint("查找 80 的结果：", bst.search(80)) # 输出：Trueprint("查找 100 的结果：", bst.search(100)) # 输出：Falsebst.delete(20)print("删除 20 后查找 20 的结果：", bst.search(20)) # 输出：False```六、实验结果与分析1. 检索树的构建：通过定义树节点类和检索树类，实现了检索树的构建。

二叉树实验报告总结（共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．实验要求根据二叉排序树的抽象数据类型的定义，使用二叉链表实现一个二叉排序树。

二叉排序树的基本功能：1. 二叉排序树的建立2. 二叉排序树的查找3. 二叉排序树的插入4. 二叉排序树的删除5. 二叉排序树的销毁6. 其他：自定义操作编写测试main() 函数测试二叉排序树的正确性2. 程序分析2.1 存储结构二叉链表般为流程图2.2 程序流程 (或程序结构、或类关系图等表明程序构成的内容，等)2.2.1.流程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);}删除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;}else{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这个函数，找到数值与需要删除节点的数值相等的节点时，调用delete这个函数。

实验报告实验三二叉排序树的建立和查找

实验三二叉排序树的建立和查找一、实验目的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）创建二叉排序树算法：如果任一结点的左子树非空，则左子树中的所有结点的关键码都小于根结点的关键码；如果任一结点的右子树非空，则右子树中的所有结点的关键码都大于根结点的关键码。

（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。

二叉排序树实验报告

二叉排序树实验报告二叉排序树实验报告一、引言二叉排序树，也被称为二叉搜索树，是一种常见的数据结构，它具有快速的查找和插入操作的特点。

在本次实验中，我们将探索二叉排序树的原理和实现，并通过实际操作来验证其性能和效果。

二、实验目的本次实验的目的是通过实际操作，深入理解二叉排序树的原理和实现，并通过对比不同操作的时间复杂度，评估其性能和效果。

三、实验过程1. 实验环境的搭建在开始实验之前，我们需要搭建一个合适的实验环境。

我们可以选择使用C++或者其他编程语言来实现二叉排序树。

在本次实验中，我们选择使用C++来实现。

2. 二叉排序树的实现首先，我们需要定义一个二叉排序树的数据结构。

这个数据结构包含一个根节点，每个节点包含一个值和两个指针，分别指向左子树和右子树。

通过递归的方式，我们可以实现二叉排序树的插入、删除和查找操作。

3. 实验数据的准备为了验证二叉排序树的性能和效果，我们需要准备一组实验数据。

这组数据可以是随机生成的整数，也可以是具有特定规律的数据。

我们可以选择不同规模的数据集来进行实验，以评估二叉排序树在不同情况下的表现。

4. 实验操作的执行通过实验数据的准备，我们可以开始执行实验操作。

首先，我们将数据依次插入到二叉排序树中，并记录下插入操作的时间。

然后，我们可以执行查找操作，查找树中是否包含某个特定的值，并记录下查找操作的时间。

最后，我们可以执行删除操作，删除树中的某个节点，并记录下删除操作的时间。

5. 实验结果的分析通过实验操作的执行，我们可以得到一组实验结果。

我们可以通过对比不同操作的时间复杂度，来评估二叉排序树的性能和效果。

同时，我们还可以观察实验结果中树的结构，以验证二叉排序树的正确性。

四、实验结果与讨论通过实验操作的执行，我们得到了一组实验结果。

我们可以观察到，随着数据规模的增加，插入、查找和删除操作的时间逐渐增加。

这是因为二叉排序树的操作时间复杂度与树的高度相关，当树的高度增加时，操作的时间复杂度也会增加。

数据结构实验-二叉排序树应用实验报告（内容清晰）

数据结构实验-二叉排序树应用实验报告（内容清晰）实验报告实验课程：数据结构实验项目：实验四二叉排序树应用专业：计算机科学与技术班级：姓名：学号：指导教师：目录一、问题定义及需求分析（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;。

二叉排序树的查找实验报告

数据结构试验报告 二叉排序树的操作

数据结构二叉排序树实验报告

实验报告：二叉树

实验六 折半和二叉排序树查找实验

二叉排序树的实验报告

二叉排序树实验报告

数据结构与算法实验报告 二叉排序树

利用二叉排序树对一组数据排序并查找元素

实验报告平衡二叉树

二叉排序树的查找与性能分析

对于二叉排序树的实现的实践成果报告

树的查找实验报告

二叉排序树实验报告

检索树的实验报告

二叉树实验报告总结（共10篇）

二叉排序树实验报告

实验报告 实验三 二叉排序树的建立和查找

数据结构实验报告-二叉排序树的插入和检索

二叉排序树实验报告

数据结构实验-二叉排序树应用实验报告（内容清晰）

数据结构试验报告二叉排序树的操作

实验六折半和二叉排序树查找实验

数据结构与算法实验报告二叉排序树

实验报告实验三二叉排序树的建立和查找