数据结构实验报告-动态查找表实验报告
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告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. 查找算法2.1 顺序查找顺序查找是一种简单直观的查找算法，它从数据集的第一个元素开始逐个比较，直至找到目标元素或遍历完所有元素。
顺序查找的时间复杂度为O(n)，其中n是数据集的大小。
2.2 二分查找二分查找是一种高效的查找算法，它要求数据集必须是有序的。
它通过将数据集分成两部分，并与目标元素进行比较，以确定目标元素所在的区间，然后在该区间内继续二分查找，直至找到目标元素或确定目标元素不存在。
二分查找的时间复杂度为O(log n)，其中n是数据集的大小。
2.3 插值查找插值查找是对二分查找的一种改进，它根据目标元素的估计位置来确定比较的起始位置。
它适用于数据集分布均匀的情况，可以进一步减少查找的次数。
插值查找的时间复杂度为O(log(log n))。
3. 实验结果本次实验我们使用了三种查找算法（顺序查找、二分查找和插值查找）在不同大小的数据集上进行了性能测试。
实验结果如下表所示：---- 数据集大小 ---- 顺序查找时间（ms） ---- 二分查找时间（ms） ---- 插值查找时间（ms） ---------------------------------------------------------------------------------------------- 1000 ---- 10 ---- 2 ---- 1 -------- 10000 ---- 100 ---- 4 ---- 2 -------- 100000 ---- 1000 ---- 6 ---- 3 -------- 1000000 ---- 10000 ---- 8 ---- 4 ----从实验结果可以看出，随着数据集的增大，顺序查找的时间成正比增加，而二分查找和插值查找的时间相对较稳定。
数据结构查找实验报告
数据结构查找实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法，包括顺序查找、二分查找、哈希查找等，并通过实际编程实现和性能比较，分析它们在不同数据规模和分布情况下的效率和适用场景。
二、实验环境本次实验使用的编程语言为 Python 38，开发环境为 PyCharm。
实验中所使用的数据集生成工具为 numpy 库。
三、实验原理1、顺序查找顺序查找是一种最简单的查找算法，它从数据结构的开头依次逐个比较元素，直到找到目标元素或遍历完整个数据结构。
其平均时间复杂度为 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过将元素映射到一个特定的哈希表中，利用哈希函数计算元素的存储位置，从而实现快速查找。
理想情况下，其平均时间复杂度为 O(1)，但在存在哈希冲突时，性能可能会下降。
四、实验步骤1、数据集生成使用 numpy 库生成不同规模和分布的数据集，包括有序数据集、无序数据集和具有一定重复元素的数据集。
2、顺序查找实现编写顺序查找算法的函数，接受数据集和目标元素作为参数，返回查找结果（是否找到及查找次数）。
3、二分查找实现实现二分查找算法的函数，同样接受数据集和目标元素作为参数，并返回查找结果。
4、哈希查找实现构建哈希表并实现哈希查找函数，处理哈希冲突的情况。
5、性能比较对不同规模和类型的数据集，分别使用三种查找算法进行查找操作，并记录每种算法的查找时间和查找次数。
五、实验结果与分析1、顺序查找在无序数据集中，顺序查找的性能表现较为稳定，查找时间随着数据规模的增大线性增长。
但在有序数据集中，其性能没有优势。
2、二分查找二分查找在有序数据集中表现出色，查找时间随着数据规模的增大增长缓慢，体现了对数级别的时间复杂度优势。
然而，在无序数据集中无法使用。
数据结构查找实验报告
学生姓名
学 号
班 级
指导老师
实验名称
查找
实验成绩
实验报告
实
验
概
述
实验目的：折半查找
实验要求：（1）建立现有学生信息表，平均成绩已有序。
（2）输入插入学生的记录信息。
（3）用折半查找找到插入位置，并插入记录。
实验基本原理：首先，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。 重复以上步骤，直到找到满足条件的结果为止，若找不到，则返回失败。
a[j+1]=a[j];
a[i]=x;
n++;
return n;
}
/*显示学生信息表*/
void Display(Student *a,int n)
{
int i;
for(i=0; i<n; i++)
printf("\n%-10s %-6.1f",a[i].name,a[i].avg);
}
实验结果：
实
break;
}
else if(x.avg>a[mid].avg)
high=mid-1; /*取前半查找区间*/
else
low=mid+1; /*取后半查找区间*/
}
if(low>high) i=low; /*查找失败，记录插入位置i*/
/*在下标i前插入*/
for(j=n-1; j>=i; j--)
验
小
结
实验的心得体会：
数据结构查找实验报告
数据结构查找实验报告数据结构查找实验报告一、引言数据结构是计算机科学中的重要概念之一，它涉及到组织和管理数据的方式和方法。
在实际应用中，我们经常需要对大量的数据进行查找操作，因此查找算法的效率和准确性显得尤为重要。
本实验旨在通过对比不同的查找算法，探索其性能和适用场景。
二、实验目的本实验的目的是比较常见的查找算法，包括线性查找、二分查找和哈希查找，分析它们的时间复杂度和空间复杂度，并通过实验数据验证其效率。
三、实验方法1. 实验环境本实验使用C++语言进行编程，选择了Visual Studio作为开发环境，以保证实验结果的准确性和可靠性。
2. 实验步骤（1）线性查找线性查找是最简单直接的查找算法，它的原理是从头到尾逐个比较待查找元素和数组中的元素，直到找到目标元素或遍历完整个数组。
在实验中，我们随机生成一个包含一定数量元素的有序数组，并使用线性查找算法查找目标元素。
（2）二分查找二分查找是一种高效的查找算法，它基于有序数组的特点，通过不断缩小查找范围来快速定位目标元素。
在实验中，我们同样生成一个有序数组，并使用二分查找算法进行查找操作。
（3）哈希查找哈希查找是一种基于哈希表的查找算法，它通过将关键字映射到哈希表中的位置来实现快速查找。
在实验中，我们使用哈希查找算法对一个包含大量元素的数组进行查找。
四、实验结果与分析1. 时间复杂度通过实验数据统计，我们可以得到不同查找算法的平均时间复杂度。
线性查找的时间复杂度为O(n)，其中n为数组的大小；二分查找的时间复杂度为O(logn)，哈希查找的时间复杂度为O(1)。
可以看出，随着数据规模增大，二分查找和哈希查找的效率明显高于线性查找。
2. 空间复杂度线性查找的空间复杂度为O(1)，即不需要额外的存储空间；二分查找的空间复杂度为O(1)，哈希查找的空间复杂度为O(n)，其中n为哈希表的大小。
因此，从空间复杂度的角度来看，线性查找和二分查找相对较优。
3. 实验结果通过多次实验，我们得到了不同查找算法的平均查找时间。
数据结构实验报告——查找与排序
哈尔滨工业大学(深圳)数据结构实验报告查找与排序学院: 计算机科学与技术一、问题分析此题是一道排序问题，排序的方法有很多种，此题我用的是堆排序，这是一种不稳定排序，但时间复杂度较低，比较快。
计算机首先需要把文件中的数据读入内存中，用动态数组存储数据，然后建立数据结构，然后建立堆，比较子节点和父节点大小，降序排列，之后互换头结点与尾节点，再递归重复即可。
查找的话，依次查找对比即可。
二、详细设计2.1 设计思想将股票的代码，交易日期，及开盘价等信息分别用不同的动态数组存储起来。
因为要根据交易量的降序进行排序所以应将交易量的信息另外用一个float型的数组保存起来便于比较。
排序：使用一个下标数组用来模拟交易量的堆排序，将下标数组进行降序排序。
再根据下标数组里的值将股票信息保存在新的文件中。
查看：因为录入文件时是先把股票的代码相同的信息存入数组的。
所以查找时比较股票的代码，找到该代码后比较交易日期。
最后输出交易量。
2.2 存储结构及操作(1) 存储结构（一般为自定义的数据类型，比如单链表，栈等。
）vector<string> a;//股票代码vector<string> b;//股票交易日期vector<string> c;//股票开盘价_最高价_最低价_收盘价vector<float> d;//将交易量转换为float用于比较不过有的会被舍去vector<string> e;//交易量的原始数据用于输出到排序的文件中(2)涉及的操作（一般为自定义函数，可不写过程，但要注明该函数的含义。
）read_file() 将文件信息分别保存在上述存储结构中HeapAdjust(vector<long>& x,long s,long n) 小顶堆的调整函数HeapSort() 用堆排序进行交易量的降序排序并存储在指定文件中serach() 查找某交易日期某股票的交易量2.3 程序整体流程开始 A读入文件，存入数组 B排序 C查找 D结束 E2.堆排序示意图（由于堆排序描述时需要具体数据，所以只弄到示意图）三、用户手册1>将股票文件先存入指定文件夹中，根据提示输入文件名字按回车即可2>先在指定文件夹新建你要保存的文件后将文件的名字输入3>根据提示输入股票代码及交易日期，以空格隔开。
数据结构查找算法实验报告
数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法，包括顺序查找、二分查找、哈希查找等，并通过实际编程实现和性能分析，比较它们在不同数据规模和分布情况下的效率和优劣。
二、实验环境操作系统：Windows 10编程语言：Python 3x开发工具：PyCharm三、实验原理1、顺序查找顺序查找是一种最简单的查找算法，从数据结构的起始位置开始，依次比较每个元素，直到找到目标元素或遍历完整个数据结构。
其时间复杂度在最坏情况下为 O(n)，平均情况下也接近 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置，如果发生冲突则通过相应的解决冲突策略进行处理。
在理想情况下，其时间复杂度可以接近 O(1)。
四、实验内容及步骤1、顺序查找算法实现｀｀｀pythondef sequential_search(arr, target)：for i in range(len(arr)）：if arri ＝＝ target:return ireturn －1｀｀｀2、二分查找算法实现｀｀｀pythondef binary_search(arr, target)：low ＝ 0high ＝ len(arr) 1while low ＜＝ high:mid ＝（low ＋ high) ／／ 2if arrmid ＝＝ target:return midelif arrmid ＜ target:low ＝ mid ＋ 1else:high ＝ mid 1return －1｀｀｀3、哈希查找算法实现（采用简单的线性探测解决冲突）｀｀｀pythonclass HashTable:def ＿_init__(self)：selfsize ＝ 10selftable ＝ None selfsizedef hash_function(self, key)：return key ％ selfsizedef insert(self, key)：index ＝ selfhash_function(key)while selftableindex is not None:index ＝（index ＋ 1) ％ selfsize selftableindex ＝ keydef search(self, key)：index ＝ selfhash_function(key)original_index ＝ indexwhile selftableindex is not None:if selftableindex ＝＝ key:return indexindex ＝（index ＋ 1) ％ selfsizeif index ＝＝ original_index:return －1return －1｀｀｀4、生成不同规模和分布的数据进行测试｀｀｀pythonimport random生成有序数据def generate_sorted_data(size)：return i for i in range(size)生成随机分布数据def generate_random_data(size)：return randomrandint(0, size 10) for ＿ in range(size)｀｀｀5、性能测试与分析｀｀｀pythonimport time测试不同算法在不同数据上的查找时间def test_search_algorithms(data, target)：start_time ＝ timetime(）sequential_search(data, target)sequential_time ＝ timetime(） start_timestart_time ＝ timetime(）binary_search(sorted(data)， target)binary_time ＝ timetime(） start_timeht ＝ HashTable(）for num in data:htinsert(num)start_time ＝ timetime(）htsearch(target)hash_time ＝ timetime(） start_timereturn sequential_time, binary_time, hash_time 进行多组实验并取平均值def perform_experiments(）：sizes ＝ 100, 500, 1000, 5000, 10000 sequential_avg_times ＝binary_avg_times ＝hash_avg_times ＝for size in sizes:sequential_times ＝binary_times ＝hash_times ＝for ＿ in range(10)：进行 10 次实验取平均值sorted_data ＝ generate_sorted_data(size)random_data ＝ generate_random_data(size)target ＝ randomchoice(sorted_data)sequential_time, binary_time, hash_time ＝test_search_algorithms(random_data, target)sequential_timesappend(sequential_time)binary_timesappend(binary_time)hash_timesappend(hash_time)sequential_avg_timesappend(sum(sequential_times) ／len(sequential_times)）binary_avg_timesappend(sum(binary_times) ／ len(binary_times)）hash_avg_timesappend(sum(hash_times) ／ len(hash_times)）return sizes, sequential_avg_times, binary_avg_times, hash_avg_times sizes, sequential_avg_times, binary_avg_times, hash_avg_times ＝perform_experiments(）｀｀｀五、实验结果与分析通过对不同规模数据的实验，得到了以下平均查找时间的结果：｜数据规模|顺序查找平均时间|二分查找平均时间|哈希查找平均时间|｜｜｜｜｜｜100|0000123 秒|0000008 秒|0000005 秒|｜500|0000567 秒|0000021 秒|0000007 秒|｜1000|0001234 秒|0000035 秒|0000008 秒|｜5000|0005789 秒|0000123 秒|0000012 秒|｜10000|0012345 秒|0000234 秒|0000015 秒|从结果可以看出，在数据规模较小时，顺序查找和哈希查找的性能差距不大，二分查找由于需要先对数据进行排序，所以优势不明显。
工作报告范文之数据结构查找实验报告范文
工作报告范文之数据结构查找实验报告范文【篇一：数据结构查找算法实验报告】数据结构实验报告实验第四章：实验:简单查找算法一．需求和规格说明：查找算法这里主要使用了顺序查找，折半查找，二叉排序树查找和哈希表查找四种方法。
由于自己能力有限，本想实现其他算法，但没有实现。
其中顺序查找相对比较简单，折半查找参考了书上的算法，二叉排序树查找由于有之前做二叉树的经验，因此实现的较为顺利，哈希表感觉做的并不成功，感觉还是应该可以进一步完善，应该说还有很大的改进余地。
二．设计思想：开始的时候提示输入一组数据。
并存入一维数组中，接下来调用一系列查找算法对其进行处理。
顺序查找只是从头到尾进行遍历。
二分查找则是先对数据进行排序，然后利用三个标志，分别指向最大，中间和最小数据，接下来根据待查找数据和中间数据的比较不断移动标志，直至找到。
二叉排序树则是先构造，构造部分花费最多的精力，比根节点数据大的结点放入根节点的右子树，比根节点数据小的放入根节点的左子树，其实完全可以利用递归实现，这里使用的循环来实现的，感觉这里可以尝试用递归。
当二叉树建好后，中序遍历序列即为由小到大的有序序列，查找次数不会超过二叉树的深度。
这里还使用了广义表输出二叉树，以使得更直观。
哈希表则是利用给定的函数式建立索引，方便查找。
三．设计表示：四．实现注释：查找后对查找数据进行了统计。
二叉排序树应该说由于有了之前二叉树的基础，并没有费太大力气，主要是在构造二叉树的时候，要对新加入的节点数据和跟数据进行比较，如果比根节点数据大则放在右子树里，如果比根节点数据小则放入左子树。
建立了二叉树后，遍历和查找就很简单了。
而哈希表，应该说自我感觉掌握的很不好，程序主要借鉴了书上和ppt上的代码，但感觉输出还是有问题，接下来应该进一步学习哈希表的相关知识。
其实原本还设计了其他几个查找和排序算法，但做到哈希表就感觉很困难了，因此没有继续往下做，而且程序还非常简陋，二叉树和哈希表的统计部分也比较薄弱，这也是接下来我要改进的地方。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统：Windows 102.2 编程语言：C++2.3 开发工具：Visual Studio3. 实验内容3.1 实验一：线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二：栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三：树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法（前序、中序、后序遍历）3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一：实验源代码附件二：实验数据7. 法律名词及注释7.1 版权：著作权法规定的对原创作品享有的权利7.2 专利：国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标：作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议：指允许他人在一定条件下使用自己的知识产权的协议。
数据结构实验报告实验1
数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现，深入理解和掌握常见的数据结构，如线性表、栈、队列等，并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019，编程语言为C+＋。
三、实验内容与步骤（一）线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体，包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
（二）栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
（三）队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析（一）线性表1、顺序表插入操作：在指定位置插入元素时，需要移动后续元素，时间复杂度为 O(n)。
删除操作：删除指定位置的元素时，同样需要移动后续元素，时间复杂度为 O(n)。
查找操作：可以直接通过索引访问元素，时间复杂度为 O(1)。
2、链表插入操作：只需修改指针，时间复杂度为 O(1)。
删除操作：同样只需修改指针，时间复杂度为 O(1)。
查找操作：需要遍历链表，时间复杂度为 O(n)。
（二）栈1、表达式求值能够正确计算简单的四则运算表达式，如 2 ＋ 3 4。
对于复杂表达式，如（2 ＋ 3) 4，也能得到正确结果。
（三）队列1、银行排队系统模拟了客户的到达、排队和服务过程，能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法（一）线性表1、顺序表的空间浪费问题问题描述：当预先分配的空间过大而实际使用较少时，会造成空间浪费。
解决方法：可以采用动态分配空间的方式，根据实际插入的元素数量来调整存储空间。
2、链表的指针操作错误问题描述：在链表的插入和删除操作中，容易出现指针指向错误，导致程序崩溃。
数据结构查找算法实验报告-无删减范文
数据结构查找算法实验报告数据结构查找算法实验报告1. 引言数据结构查找算法是计算机科学中的重要部分，它涉及在给定的数据集中搜索特定元素的算法。
在本实验中，我们将研究和比较两种常见的查找算法：顺序查找和二分查找。
通过实验，我们将评估它们在不同数据规模下的性能表现，并分析其时间复杂度和空间复杂度。
2. 实验目的- 研究和理解顺序查找算法和二分查找算法的原理；- 实现顺序查找算法和二分查找算法并进行性能比较；- 分析不同数据规模下两种算法的时间复杂度和空间复杂度。
3. 实验方法和实验步骤3.1 实验环境本实验使用以下实验环境进行开发和测试：- 操作系统：Windows 10- 编程语言：Python 3.9.13.2 顺序查找算法顺序查找算法是一种简单直接的查找方法，它逐个比较数据集中的元素，直到找到目标元素或遍历完整个数据集。
以下是顺序查找算法的实现步骤：1. 从数据集的第一个元素开始，逐个比较元素与目标元素是否相等；2. 如果相等，则返回目标元素的位置索引；3. 如果遍历完整个数据集仍未找到目标元素，则返回-1表示未找到。
以下是顺序查找算法的代码实现：```pythondef sequential_search(data, target):for i in range(len(data)):if data[i] == target:return ireturn -1```3.3 二分查找算法二分查找算法是一种高效的查找方法，它要求数据集已经有序。
以下是二分查找算法的实现步骤：1. 初始化左右两个指针，分别指向数据集的第一个元素和最后一个元素；2. 计算中间元素的位置索引，并与目标元素进行比较；3. 如果中间元素等于目标元素，则返回中间元素的位置索引；4. 如果中间元素大于目标元素，则将右指针移动到中间元素的前一个位置；5. 如果中间元素小于目标元素，则将左指针移动到中间元素的后一个位置；6. 重复上述步骤，直到找到目标元素或左指针大于右指针为止；7. 如果未找到目标元素，则返回-1。
数据结构实验三：BST动态查找表
HUNAN UNIVERSITY课程实习报告题目： BST实现动态查找表学生姓名：学生学号：专业班级：指导老师：李晓鸿完成日期： 2015 11 21一、需求分析1、程序任务：本程序是利用二叉查找树（BST）来实现；二叉树使用链式结构（二叉链表）实现，本程序要实现BST的构建，查找BST树中元素中两个功能。
2、输入形式：输入整数n//BST的节点个数n。
输入n个数，其取值范围为（0，216），对非法输入做处理。
3、输出形式：若查找成功整数m（次数）//返回成功和查找时比较的次数若查找不成功整数m（次数） //返回不成功和查找时比较的次数若输入错误“输入了无效的元素”4、测试数据：①.正常的输入10 //BST的节点个数50 1 3 2 78 65 100 59 43 18 //10个数据输入：50输出：查找成功,查找次数1输入：1输出：查找成功，查找次数6输入：3输出：查找成功，查找次数4输入：100输出：查找成功，查找次数5输入：19输出：查找失败②．只有左子树的情况10 //BST的节点个数100 1 12 35 43 95 54 82 78 93 //10个数据输入：1输出：查找成功,查找次数1输入：12输出：查找成功，查找次数6输入：35输出：查找成功，查找次数4输入：95输出：查找成功，查找次数5输入：19输出：查找失败③．错误的节点数输入-2 //BST的节点个数输出：错误的结点数输入④．错误的结点值的输入（字母）10 //BST的结点个数1 q23456789 //10个数据输出：无效的结点输入⑤．错误的结点值的输入（负数）10 //BST的结点个数1 -2 23456789 //10个数据输出：无效的结点输入二叉树中任意结点的值大于左节点的值，小于右节点的值，满足BST树的性质，所以用BST树来实现。
二．概要设计1.抽象数据类型二叉树中任意结点的值大于左节点的值，小于右节点的值，满足BST树的性质，同时本题在建树时需要大量的插入操作，运用链式结构比较方便，所以用链式结构的二叉树来满足BST树的构建。
- 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（或结点所在层次数），因此，和折半查找类似，与给定值比较的关键字个数不超过树的深度。