数据结构实验报告-动态查找表实验报告
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告1·实验目的本实验旨在研究不同的查找算法在不同数据结构下的性能表现，通过实验结果对比分析，选取最优算法来完成查找操作。
2·实验方法2·1 数据结构选择在本实验中，我们选择了常用的数据结构进行查找性能比较，包括线性表、二叉树、哈希表等。
2·2 查找算法选择我们选择了以下常用的查找算法进行实验：●顺序查找●二分查找●插值查找●二叉查找树●平衡二叉查找树（AVL树）●哈希查找3·实验过程3·1 实验环境设置首先，我们需要搭建合适的实验环境，包括编程语言选择、编译器、开发环境等。
在本次实验中，我们选择了C++编程语言，并使用了Visual Studio 2019作为开发环境。
3·2 实验步骤为了比较各个查找算法的性能，我们按照以下步骤进行实验： 1·创建用于查找的数据结构，并初始化数据集合。
2·调用每个查找算法进行查找，并记录查找耗时。
3·分析实验结果，比较各个查找算法的性能。
4·实验结果与分析根据实验步骤中记录的各个查找算法的耗时，我们得到了以下结果：●对于小规模数据集，顺序查找表现较好。
●对于有序数据集，二分查找和插值查找表现最佳。
●对于动态数据集，哈希表的查找效率最高。
5·结论根据实验结果与分析，我们得出以下结论：●不同的数据结构适用于不同的查找需求。
●在静态有序数据集中，二分查找和插值查找是较好的选择。
●在动态数据集中，哈希表具有较高的查找效率。
附件：附件1：实验数据集附件2：查找算法代码法律名词及注释：1·数据结构：数据之间的组织方式和关系，使得我们可以高效地进行数据的存储和操作。
2·查找算法：在给定某个目标值的情况下，在给定数据集内寻找目标值的算法。
3·顺序查找：逐个比较目标值和数据集内的元素，直到找到目标值或者遍历完整个数据集。
数据结构实验报告_实验报告_
数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是小编给大家整理收集的数据结构实验报告，供大家阅读参考。
数据结构实验报告1一、实验目的及要求1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。
本实验训练的要点是“栈”和“队列”的观点;二、实验内容1) 利用栈，实现数制转换。
2) 利用栈，实现任一个表达式中的语法检查(选做)。
3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);三、实验流程、操作步骤或核心代码、算法片段顺序栈：Status InitStack(SqStack &S){S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status DestoryStack(SqStack &S){free(S.base);return OK;}Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status StackEmpty(SqStack S){if(S.base==S.top)return OK;return ERROR;}int StackLength(SqStack S){return S.top-S.base;}Status GetTop(SqStack S,ElemType &e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;Status Push(SqStack &S,ElemType e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S){ElemType *p;p=(ElemType *)malloc(sizeof(ElemType));if(!p) return ERROR;p=S.top;while(p!=S.base)//S.top上面一个...p--;printf("%d ",*p);}return OK;}Status Compare(SqStack &S){int flag,TURE=OK,FALSE=ERROR; ElemType e,x;InitStack(S);flag=OK;printf("请输入要进栈或出栈的元素："); while((x= getchar)!='#'&&flag) {switch (x){case '(':case '[':case '{':if(Push(S,x)==OK)printf("括号匹配成功!\n\n"); break;case ')':if(Pop(S,e)==ERROR || e!='('){printf("没有满足条件\n");flag=FALSE;}break;case ']':if ( Pop(S,e)==ERROR || e!='[')flag=FALSE;break;case '}':if ( Pop(S,e)==ERROR || e!='{')flag=FALSE;break;}}if (flag && x=='#' && StackEmpty(S)) return OK;elsereturn ERROR;}链队列：Status InitQueue(LinkQueue &Q) {Q.front =Q.rear=(QueuePtr)malloc(sizeof(QNode));if (!Q.front) return ERROR;Q.front->next = NULL;return OK;}Status DestoryQueue(LinkQueue &Q) {while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue &Q){if(Q.front->next==NULL)return OK;return ERROR;}Status QueueLength(LinkQueue Q){int i=0;QueuePtr p,q;p=Q.front;while(p->next){i++;p=Q.front;q=p->next;p=q;}return i;}Status GetHead(LinkQueue Q,ElemType &e) {QueuePtr p;p=Q.front->next;if(!p)return ERROR;e=p->data;return e;}Status ClearQueue(LinkQueue &Q){QueuePtr p;while(Q.front->next ){p=Q.front->next;free(Q.front);Q.front=p;}Q.front->next=NULL;Q.rear->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e) {QueuePtr p;p=(QueuePtr)malloc(sizeof (QNode));if(!p)return ERROR;p->data=e;p->next=NULL;Q.rear->next = p;Q.rear=p; //p->next 为空return OK;}Status DeQueue(LinkQueue &Q,ElemType &e) {QueuePtr p;if (Q.front == Q.rear)return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front; //只有一个元素时(不存在指向尾指针) free (p);return OK;}Status QueueTraverse(LinkQueue Q){QueuePtr p,q;if( QueueEmpty(Q)==OK){printf("这是一个空队列!\n");return ERROR;}p=Q.front->next;while(p){q=p;printf("%d<-\n",q->data);q=p->next;p=q;}return OK;}循环队列：Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OWERFLOW);Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e){if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}int QueueLength(SqQueue Q){return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status DestoryQueue(SqQueue &Q){free(Q.base);return OK;}Status QueueEmpty(SqQueue Q) //判空{if(Q.front ==Q.rear)return OK;return ERROR;}Status QueueTraverse(SqQueue Q){if(Q.front==Q.rear)printf("这是一个空队列!");while(Q.front%MAXQSIZE!=Q.rear){printf("%d<- ",Q.base[Q.front]);Q.front++;}return OK;}数据结构实验报告2一.实验内容：实现哈夫曼编码的生成算法。
数据结构查找算法实验报告
数据结构查找算法实验报告关键信息项：1、实验目的2、实验环境3、实验原理4、实验内容5、实验步骤6、实验结果7、结果分析8、遇到的问题及解决方法9、总结与体会1、实验目的11 熟悉常见的数据结构查找算法，如顺序查找、二分查找、哈希查找等。
111 掌握不同查找算法的基本原理和实现方法。
112 通过实验比较不同查找算法的性能，分析其时间复杂度和空间复杂度。
113 培养运用数据结构和算法解决实际问题的能力。
2、实验环境21 操作系统：具体操作系统名称211 编程语言：具体编程语言名称212 开发工具：具体开发工具名称3、实验原理31 顺序查找顺序查找是从数据结构的一端开始，依次逐个比较给定的关键字与数据元素的关键字，直到找到相等的元素或者遍历完整个数据结构为止。
其时间复杂度为 O(n)。
32 二分查找二分查找要求数据结构是有序的。
通过不断将待查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
33 哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置，然后在该位置进行比较。
如果发生冲突，则通过解决冲突的方法来查找目标元素。
其平均时间复杂度接近O(1)，但在最坏情况下可能会退化为O(n)。
4、实验内容41 实现顺序查找算法，并对给定的无序数组进行查找操作。
411 实现二分查找算法，并对给定的有序数组进行查找操作。
412 实现哈希查找算法，并对给定的数据集进行查找操作。
413 对不同规模的数据集，分别使用上述三种查找算法进行查找，并记录查找时间和比较次数。
5、实验步骤51 顺序查找算法实现511 定义顺序查找函数，接受数组和要查找的关键字作为参数。
512 从数组的第一个元素开始，逐个比较关键字与数组元素的关键字。
513 如果找到相等的元素，返回该元素的索引；如果遍历完数组都未找到，返回－1。
52 二分查找算法实现521 定义二分查找函数，接受有序数组、要查找的关键字以及数组的起始和结束索引作为参数。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构，由结点和边组成。
树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中，我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树，每个结点最多只有两个子结点。
根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。
然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。
如果当前结点为空，则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。
如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。
- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。
- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。
数据结构查找实验报告
一、实验目的1. 理解并掌握几种常见查找算法的基本原理和实现方法。
2. 比较不同查找算法的时间复杂度和空间复杂度。
3. 通过实验验证查找算法的效率和适用场景。
二、实验内容本次实验主要涉及以下查找算法：1. 顺序查找法2. 二分查找法3. 散列查找法三、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发环境：PyCharm四、实验步骤1. 实现顺序查找法2. 实现二分查找法3. 实现散列查找法4. 编写测试程序，分别对三种查找算法进行测试5. 比较三种查找算法的性能五、实验结果与分析1. 顺序查找法（1）实现代码```pythondef sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1```（2）测试程序```pythonarr = [5, 3, 8, 6, 2, 7, 4, 9, 1]target = 6print("顺序查找结果：", sequential_search(arr, target))```（3）分析顺序查找法的时间复杂度为O(n)，空间复杂度为O(1)。
当数据量较大时，查找效率较低。
2. 二分查找法（1）实现代码```pythondef binary_search(arr, target):left, right = 0, len(arr) - 1while left <= right:mid = (left + right) // 2if arr[mid] == target:return midelif arr[mid] < target:left = mid + 1else:right = mid - 1return -1```（2）测试程序```pythonarr = [1, 2, 3, 4, 5, 6, 7, 8, 9]target = 6print("二分查找结果：", binary_search(arr, target))```（3）分析二分查找法的时间复杂度为O(log2n)，空间复杂度为O(1)。
动态查找表实验报告
动态查找表实验报告篇一：动态查找表实验报告动态查找表实验报告一.1 、实验概要实验项目名称: 抽象数据类型的实现实验项目性质: 设计性实验所属课程名称: 数据结构实验计划学时: 62、实验目的对某个具体的抽象数据类型，运用课程所学的知识和方法，设计合理的数据结构，并在此基础上实现该抽象数据类型的全部基本操作。
通过本设计性实验，检验所学知识和能力，发现学习中存在的问题。
进而达到熟练地运用本课程中的基础知识及技术的目的。
实验要求如下：1．参加实验的学生应首先了解设计的任务，然后根据自己的基础和能力从中选择一题。
一般来说，选择题目应以在规定的时间内能完成，并能得到应有的锻炼为原则。
若学生对教材以外的相关题目较感兴趣，希望选作实验的题目时，应征得指导教师的认可，并写出明确的抽象数据类型定义及说明。
2. 实验前要作好充分准备，包括：理解实验要求，掌握辅助工具的使用，了解该抽象数据类型的定义及意义，以及其基本操作的算法并设计合理的存储结构。
3. 实验时严肃认真，要严格按照要求独立进行设计，不能随意更改。
注意观察并记录各种错误现象，纠正错误，使程序满足预定的要求，实验记录应作为实验报告的一部分。
4. 实验后要及时总结，写出实验报告，并附所打印的问题解答、程序清单，所输入的数据及相应的运行结果。
所用软件环境或工具：DEV-C++5可视化编程环境.3.动态查找表的抽象数据类型ADT DynamicSearchTable {数据对象D：D是具有相同特性的数据元素的集合。
每个数据元素含有类型相同的关键字，可唯一标识数据元素。
数据关系R：数据元素同属一个集合。
基本操作P：InitDSTable(&DT);操作结果：构造一个空的动态查找表DT。
DestroyDSTable(&DT);初始条件：动态查找表DT存在；操作结果：销毁动态查找表DT。
SearchDSTable(DT, key);初始条件：动态查找表DT存在，key为和关键字类型相同的给定值；操作结果：若DT中存在其关键字等于key的数据元素，则函数值为该元素的值或在表中的位置，否则为“空”。
数据结构实验报告
数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践，掌握基本的数据结构概念、原理及其应用，培养学生的问题分析与解决能力，提升编程实践能力。
二、实验背景数据结构是计算机科学中的重要基础，它研究数据的存储方式和组织形式，以及数据之间的关系和操作方法。
在软件开发过程中，合理选用和使用数据结构，能够提高算法效率，优化内存利用，提升软件系统的性能和稳定性。
三、实验内容本次实验主要涉及以下几个方面的内容：1.线性表的基本操作：包括线性表的创建、插入、删除、查找、修改等操作。
通过编程实现不同线性表的操作，掌握它们的原理和实现方法。
2.栈和队列的应用：栈和队列是常用的数据结构，通过实现栈和队列的基本操作，学会如何解决实际问题。
例如，利用栈实现括号匹配，利用队列实现银行排队等。
3.递归和回溯算法：递归和回溯是解决很多求解问题的常用方法。
通过编程实现递归和回溯算法，理解它们的思想和应用场景。
4.树和二叉树的遍历：学习树和二叉树的遍历方法，包括前序、中序和后序遍历。
通过编程实现这些遍历算法，加深对树结构的理解。
5.图的基本算法：学习图的基本存储结构和算法，包括图的遍历、最短路径、最小生成树等。
通过编程实现这些算法，掌握图的基本操作和应用。
四、实验过程1.具体实验内容安排：根据实验要求，准备好所需的编程环境和工具。
根据实验要求逐步完成实验任务，注意记录并整理实验过程中遇到的问题和解决方法。
2.实验数据采集和处理：对于每个实验任务，根据要求采集并整理测试数据，进行相应的数据处理和分析。
记录实验过程中的数据和结果。
3.实验结果展示和分析：将实验结果进行适当的展示，例如表格、图形等形式，分析实验结果的特点和规律。
4.实验总结与反思：总结实验过程和结果，回顾实验中的收获和不足，提出改进意见和建议。
五、实验结果与分析根据实验步骤和要求完成实验任务后，得到了相应的实验结果。
对于每个实验任务，根据实验结果进行适当的分析。
数据结构-查找-实验报告
实验报告实验八查找一、实验目的1、掌握顺序表查找中不同查找方法的查找思想，并能用C/C++语言实现。
2、掌握树表查找中二叉排序树查找、平衡二叉树查找的查找思想，并能用C/C++语言实现。
3、掌握Hash表查找中的查找思想，并能用C/C++语言实现。
4、能够针对具体实际，灵活选用适宜的查找方法。
二、实验环境PC微机，Windows，DOS，Turbo C或Visual C++三、实验内容1、二叉排序树查找（1）问题描述查找是计算机操作中的一种重要应用技术，查找的方法有许多，不同的查找方法有不同的查找效率，而二叉排序树查找就是效率较高的查找方法之一。
所谓二叉排序树，就是指将原来已有数据根据大小构成一棵二叉树，二叉树中的所有结点数据满足一定的大小关系，所有左子树中的结点均比根结点小，所有右子树中的结点均比根结点大。
二叉排序树查找是指按照二叉排序树中结点的关系进行查找，查找关键字首先同树根结点进行比较，如果相等则查找成功；如果比根结点小，则在左子树中查找；如果比根结点大，则在右子树中进行查找。
这种查找方法可以快速缩小查找范围，大大减少了查找关键字的比较次数，从而提高了查找效率。
（2）基本要求编程实现时，体现查找的全过程，即二叉排序树的创建、查找关键字的输入、查找关键字的查找、查找结果的输出等。
（3）算法实现#include<stdio.h>#include<stdlib.h>void Getemptylist(); // 建立空树void Getlist(); // 建立二叉排序树void SortL(); // 排序void Connectlist(); // 结点连接处理void Lookup(); // 查找typedef struct list{int data;struct list *left;struct list *right;}JD;JD *head;int L[20];int size;int num;int main(){Getemptylist();Getlist();Lookup();return 0;}//+*void Getemptylist(){printf("建立空树：\n");head=(JD*)malloc(sizeof(JD));head->left = NULL;head->right = NULL;if(!head){printf("建立失败！\n");exit(-1);}else{printf("建立成功！\n");}}void Getlist(){int i;printf("建立二叉排序树：\n");printf("请输入元素个数：");scanf("%d",&size);printf("请输入元素：");for(i = 0;i < size;i++){scanf("%d",&(L[i]));}SortL();printf("二叉排序树建立中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告题目：动态查找表学院计算机专业计算机科学与技术年级班别2009级 2 班学号3109005935学生姓名黄丽敏指导教师吴伟民成绩____________________2011年6月一. 动态查找表：抽象数据类型动态查找表的定义如下：ADT DynamicSearchTable{数据对象D：D是具有相同特性的数据元素的集合。
各个数据元素均含有类型相同，可唯一标识数据元素的关键字数据关系R：数据元素同属一个集合。
基本操作P：InitDSTable(&DT);操作结果：构造一个空的动态查找表DT。
DestroyDSTable(&DT)初始条件：动态查找表DT存在。
操作结果：销毁动态查找表DT。
SearchDSTable(DT,key);初始条件：动态查找表DT存在，key为和关键字类型相同的给定值。
操作结果：若DT中存在其关键字等于key的数据元素，则函数值为该元素的值或在表中的位置，否则为“空”。
InsertDSTable(&DT,e);初始条件：动态查找表DT存在，e为待插入的数据元素。
操作结果：若DT中不存在其关键字等于e.key的数据元素，则插入e到DT。
DeleteDSTable(&DT,key);初始条件：动态查找表DT存在，key为和关键字类型相同的给定值。
操作结果：若DT中存在其关键字等于key的数据元素，则删除之。
TraverseDSTable(DT,visit());初始条件：动态查找表DT存在，visit是对结点操作的应用函数。
操作结果：按某种次序对DT的每个结点调用函数visit()一次且至多一次，一旦visit()失败，则操作失败。
}ADT DynamicSearchTable二. 存储结构定义：公用头文件DS0.h和宏定义:#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define N 10 /* 数据元素个数 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */typedef int KeyType; /* 设关键字域为整型 */#define EQ(a,b) ((a)==(b))#define LT(a,b) ((a)<(b))二叉排序树存储结构：二叉排序树的类型BiTree定义如下：typedef int KeyType; /* 设关键字域为整型*/typedef struct{KeyType key;int others;} ElemType; /* 数据元素类型*/typedef ElemType TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild; /* 左右孩子指针*/}BiTNode,*BiTree;三、算法设计：/* 操作结果: 构造一个空的动态查找表DT */Status InitDSTable(BiTree *DT){*DT=NULL;return OK;}/* 初始条件: 动态查找表DT存在。
操作结果: 销毁动态查找表DT */void DestroyDSTable(BiTree *DT) /* 同bo6-2.c */{if(*DT) /* 非空树*/{if((*DT)->lchild) /* 有左孩子*/DestroyDSTable(&(*DT)->lchild); /* 销毁左孩子子树*/if((*DT)->rchild) /* 有右孩子*/DestroyDSTable(&(*DT)->rchild); /* 销毁右孩子子树*/free(*DT); /* 释放根结点*/*DT=NULL; /* 空指针赋0 */}}/* 在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素，*//* 若查找成功，则返回指向该数据元素结点的指针,否则返回空指针。
*/BiTree SearchBST(BiTree T,KeyType1 key){if((!T)||EQ(key,T->data.key))return T; /* 查找结束*/else if LT(key,T->data.key) /* 在左子树中继续查找*/return SearchBST(T->lchild,key);elsereturn SearchBST(T->rchild,key); /* 在右子树中继续查找*/}/* 在根指针T所指二叉排序树中递归地查找其关键字等于key的数据元素，若查找*//* 成功，则指针p指向该数据元素结点，并返回TRUE，否则指针p指向查找路径上*//* 访问的最后一个结点并返回FALSE,指针f指向T的双亲，其初始调用值为NULL */void SearchBST1(BiTree *T,KeyType1 key,BiTree f,BiTree *p,Status *flag){if(!*T) /* 查找不成功*/{*p=f;*flag=FALSE;}else if EQ(key,(*T)->data.key) /* 查找成功*/{*p=*T;*flag=TRUE;}else if LT(key,(*T)->data.key)SearchBST1(&(*T)->lchild,key,*T,p,flag); /* 在左子树中继续查找*/elseSearchBST1(&(*T)->rchild,key,*T,p,flag); /* 在右子树中继续查找*/}/* 当二叉排序树T中不存在关键字等于e.key的数据元素时，插入e并返回TRUE，*//* 否则返回FALSE。
*/Status InsertBST(BiTree *T, ElemType1 e){BiTree p,s;Status flag;SearchBST1(T,e.key,NULL,&p,&flag);if(!flag) /* 查找不成功*/{s=(BiTree)malloc(sizeof(BiTNode));s->data=e;s->lchild=s->rchild=NULL;if(!p)*T=s; /* 被插结点*s为新的根结点*/else if LT(e.key,p->data.key)p->lchild=s; /* 被插结点*s为左孩子*/elsep->rchild=s; /* 被插结点*s为右孩子*/return TRUE;}elsereturn FALSE; /* 树中已有关键字相同的结点，不再插入*/}/* 从二叉排序树中删除结点p，并重接它的左或右子树。
*/void 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; /* s指向被删结点的＂前驱＂（将被删结点前驱的值取代被删结点的值）*/if(q!=*p)q->rchild=s->lchild; /* 重接*q的右子树*/elseq->lchild=s->lchild; /* 重接*q的左子树*/free(s);}}/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点，*//* 并返回TRUE；否则返回FALSE。
*/Status DeleteBST(BiTree *T,KeyType1 key){if(!*T) /* 不存在关键字等于key的数据元素*/return FALSE;else{if EQ(key,(*T)->data.key) /* 找到关键字等于key的数据元素*/Delete(T);else if LT(key,(*T)->data.key)DeleteBST(&(*T)->lchild,key);elseDeleteBST(&(*T)->rchild,key);return TRUE;}}/* 初始条件: 动态查找表DT存在，Visit是对结点操作的应用函数*//* 操作结果: 按关键字的顺序对DT的每个结点调用函数Visit()一次且至多一次*/void TraverseDSTable(BiTree DT,void(*Visit)(ElemType1)){if(DT){TraverseDSTable(DT->lchild,Visit); /* 先中序遍历左子树*/Visit(DT->data); /* 再访问根结点*/TraverseDSTable(DT->rchild,Visit); /* 最后中序遍历右子树*/}}四、编译：1.初次编译会出现很多错误，这主要是写程序时的粗心大意还有一些潜在的定于或逻辑错误，第一次运行如下：2.错误很多，经过一番调试才发现定义结构体时出了问题，有些没用到，有些重定义了，调试后如下：3.此时只剩下很少错误，很明显是i未定义，经过修改调试后编译通过。
五、测试void print(ElemType c) /*以下主函数调用*/{printf("(%d,%d) ",c.key,c.others);}Void main() /*用于测试二叉排序树的查找*/{char q;BiTree dt,p;int i,select;KeyType j;ElemType k;ElemTyper[10]={{45,1},{12,2},{53,3},{3,4},{37,5},{24,6},{100,7},{61,8},{90,9},{70,10}}; /* 测试数据*/InitDSTable(&dt); /* 构造空表*/for(i=0;i<10;i++)InsertBST(&dt,r[i]); /* 依次插入数据元素*/H1: printf("=============动态查找表演示系统===========");printf("\n");printf("1、遍历原有表\n");printf("2、查找表内值\n");printf("3、删除表内值\n");printf("4、插入一个值\n");printf("5、销毁表\n");printf("6、退出系统");printf("\n");printf("请选择你需要的操作（1~6）：");scanf("%d",&select);switch(select){H2: case 1:printf("原有的表遍历如下：\n");TraverseDSTable(dt,print);printf("\n");printf("按任意键返回.....");getchar();getchar();system("cls");goto H1;H3: case 2:printf("原有的表遍历如下：\n");TraverseDSTable(dt,print);printf("\n");printf("\n请输入你要查找的值：");scanf("%d",&j);p=SearchBST(dt,j);if(p){printf("\n查找成功：");printf("(%d,%d)",p->data.key,p->data.others);//getchar();getchar();printf("\n是否继续查找？(Y/N):");q=getchar();getchar();if(q=='Y'||q=='y')else{system("cls");goto H1;}}else{printf("查找失败，表中无此值，是否继续查找？(Y/N):");getchar();q=getchar();if(q=='Y'||q=='y')goto H2;else{system("cls");goto H1;}}H4: case 3:printf("原有的表遍历如下：\n");TraverseDSTable(dt,print);printf("\n");printf("\n请输入你要删除的值：");scanf("%d",&j);//getchar();//q=getchar();p=SearchBST(dt,j);if(p){printf("删除此值后：\n");DeleteBST(&dt,j);TraverseDSTable(dt,print);printf("\n是否继续删除？(Y/N):");getchar();q=getchar();if(q=='Y'||q=='y')goto H4;else{system("cls");goto H1;}else{printf("删除失败，表中无此值，请按任意键返回继续....");printf("\n");getchar();getchar();goto H4;}H5: case 4:printf("原有的表遍历如下：\n");TraverseDSTable(dt,print);printf("\n");printf("请输入你要插入的值：");scanf("%d",&k.key);p=SearchBST(dt,k.key);if(!p){printf("插入此值后：\n");k.others=k.others+(N+1);InsertBST(&dt,k);TraverseDSTable(dt,print);printf("\n");printf("是否继续插入新值？(Y|N):");getchar();q=getchar();if(q=='Y'||q=='y')goto H5;else{system("cls");goto H1;}}else{printf("插入失败，表中已存在此值，请按任意键返回继续....");getchar();getchar();goto H5;}case 5:DestroyDSTable(&dt);printf("销毁成功....");goto H2;case 6:system("cls");printf("\n\n\n\n\n\n\n\n\n============谢谢使用！============");printf("\n\n\n ");system("pause");}}说明：（1）、此二叉排序树以下面为原始测试数据：{45,1},{12,2},{53,3},{3,4},{37,5},{24,6},{100,7},{61,8},{90,9},{78,10}主界面如下：（2）、若选择‘1’，则显示遍历出来的二叉排序树动态查找表，如下图：（3）、若选择‘2’则提示用户输入要查找的值，若存在，则显示查找成功，若没有此值，则提示是否继续查找，如下图：（4）、若输入3，则提示用户输入想要删除的值，若存在此值，则显示删除后的表，若不存在此值，则显示删除失败，如下图：（5）、若选择‘4’，则提示用户输入一个想要插入的值，若表中无此元素，则显示插入后的表，若已存在，则提示插入失败，如下图：（6）、若选择‘5’，则销毁此表，并显示销毁之后的表，如下图：（7）、若选择‘6’，则退出系统，显示结束系统界面：六、二叉排序树查找分析：在二叉排序树上查找其关键字等于给定值的结点的过程，恰是走了一条从根结点到该结点的路径的过程，和给定值比较的关键字个数等于路径长度加1（或结点所在层次数），因此，和折半查找类似，与给定值比较的关键字个数不超过树的深度。