实验8查找算法实现实验
(完整word版)数据结构查找算法实验报告
数据结构实验报告实验第四章：实验: 简单查找算法一．需求和规格说明：查找算法这里主要使用了顺序查找，折半查找，二叉排序树查找和哈希表查找四种方法。
由于自己能力有限，本想实现其他算法，但没有实现。
其中顺序查找相对比较简单，折半查找参考了书上的算法，二叉排序树查找由于有之前做二叉树的经验，因此实现的较为顺利，哈希表感觉做的并不成功，感觉还是应该可以进一步完善，应该说还有很大的改进余地。
二．设计思想：开始的时候提示输入一组数据。
并存入一维数组中，接下来调用一系列查找算法对其进行处理。
顺序查找只是从头到尾进行遍历。
二分查找则是先对数据进行排序，然后利用三个标志，分别指向最大，中间和最小数据，接下来根据待查找数据和中间数据的比较不断移动标志，直至找到。
二叉排序树则是先构造，构造部分花费最多的精力，比根节点数据大的结点放入根节点的右子树，比根节点数据小的放入根节点的左子树，其实完全可以利用递归实现，这里使用的循环来实现的，感觉这里可以尝试用递归。
当二叉树建好后，中序遍历序列即为由小到大的有序序列，查找次数不会超过二叉树的深度。
这里还使用了广义表输出二叉树，以使得更直观。
哈希表则是利用给定的函数式建立索引，方便查找。
三．设计表示：四．实现注释：其实查找排序这部分和前面的一些知识联系的比较紧密，例如顺序表的建立和实现，顺序表节点的排序，二叉树的生成和遍历，这里主要是中序遍历。
应该说有些知识点较为熟悉，但在实现的时候并不是那么顺利。
在查找到数据的时候要想办法输出查找过程的相关信息，并统计。
这里顺序查找和折半查找均使用了数组存储的顺序表，而二叉树则是采用了链表存储的树形结构。
为了直观起见，在用户输入了数据后，分别输出已经生成的数组和树。
折半查找由于只能查找有序表，因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计。
二叉排序树应该说由于有了之前二叉树的基础，并没有费太大力气，主要是在构造二叉树的时候，要对新加入的节点数据和跟数据进行比较，如果比根节点数据大则放在右子树里，如果比根节点数据小则放入左子树。
数据结构实验8 查找与排序
注意事项：在磁盘上创建一个目录，专门用于存储数据结构实验的程序。
因为机房机器有还原卡，请同学们将文件夹建立在最后一个盘中，以学号为文件夹名。
实验八查找和排序一、实验目的掌握运用数据结构两种基本运算查找和排序,并能通过其能解决应用问题。
二、实验要求1．掌握本实验的算法。
2．上机将本算法实现。
三、实验内容为宿舍管理人员编写一个宿舍管理查询软件, 程序采用交互工作方式,其流程如下:建立数据文件，数据结构采用线性表，存储方式任选（建议用顺序存储结构），数据元素是结构类型（学号，姓名，性别，房号），元素的值可从键盘上输入，可以在程序中直接初始化。
数据文件按关键字（学号、姓名、房号）进行排序（排序方法任选一种），打印排序结果。
（注意字符串的比较应该用strcmp(str1,str2)函数）查询菜单: (查找方法任选一种)1. 按学号查询2. 按姓名查询3. 按房号查询打印任一查询结果（可以连续操作）。
参考：typedef struct {char sno[10];char sname[2];int sex; //以0表示女，1表示男int roomno;}ElemType;struct SqList{ElemType *elem;int length;};void init(SqList &L){L.elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));L.length=0;}void printlist(SqList L){ int i;cout<<" sno name sex roomno\n";for(i=0;i<L.length;i++)cout<<setw(7)<<L.elem[i].sno<<setw(10)<<L.elem[i].sname<<setw(3)<<L.elem[i].sex<<setw(6) <<L.elem[i].roomno<<endl;}。
查找排序实验报告
查找排序实验报告一、实验目的本次实验的主要目的是深入理解和比较不同的查找和排序算法在性能和效率方面的差异。
通过实际编程实现和测试，掌握常见查找排序算法的原理和应用场景，为今后在实际编程中能够选择合适的算法解决问题提供实践经验。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
计算机配置为：处理器_____，内存_____，操作系统_____。
三、实验内容1、查找算法顺序查找二分查找2、排序算法冒泡排序插入排序选择排序快速排序四、算法原理1、顺序查找顺序查找是一种最简单的查找算法。
它从数组的一端开始，依次比较每个元素，直到找到目标元素或者遍历完整个数组。
其时间复杂度为 O(n)，在最坏情况下需要遍历整个数组。
2、二分查找二分查找适用于已排序的数组。
它通过不断将数组中间的元素与目标元素进行比较，将查找范围缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)，效率较高。
3、冒泡排序冒泡排序通过反复比较相邻的两个元素并交换它们的位置，将最大的元素逐步“浮”到数组的末尾。
每次遍历都能确定一个最大的元素，经过 n-1 次遍历完成排序。
其时间复杂度为 O(n^2)。
4、插入排序插入排序将数组分为已排序和未排序两部分，每次从未排序部分取出一个元素，插入到已排序部分的合适位置。
其时间复杂度在最坏情况下为 O(n^2)，但在接近有序的情况下性能较好。
5、选择排序选择排序每次从待排序数组中选择最小的元素，与当前位置的元素交换。
经过 n-1 次选择完成排序。
其时间复杂度为 O(n^2)。
6、快速排序快速排序采用分治的思想，选择一个基准元素，将数组分为小于基准和大于基准两部分，然后对这两部分分别递归排序。
其平均时间复杂度为 O(n log n)，在大多数情况下性能优异。
五、实验步骤1、算法实现使用Python 语言实现上述六种查找排序算法，并分别封装成函数，以便后续调用和测试。
查找算法实验报告
查找算法实验报告查找算法实验报告一、引言查找算法是计算机科学中的一个重要概念，它在数据处理和信息检索中起着关键作用。
本实验旨在探究几种常见的查找算法，并对它们的性能进行比较和分析。
二、顺序查找算法顺序查找算法是最简单直观的一种查找方法，它逐个比较待查找元素与数据集中的元素，直到找到匹配项或遍历完整个数据集。
该算法的时间复杂度为O(n)，其中n为数据集的大小。
尽管顺序查找算法的效率较低，但在小规模数据集或无序数据集中仍然具有一定的应用价值。
三、二分查找算法二分查找算法是一种高效的查找算法，它要求数据集必须是有序的。
该算法通过将待查找元素与数据集的中间元素进行比较，从而将查找范围缩小一半。
如果中间元素与待查找元素相等，则查找成功；如果中间元素大于待查找元素，则在左半部分继续查找；如果中间元素小于待查找元素，则在右半部分继续查找。
通过不断缩小查找范围，二分查找算法的时间复杂度为O(log n)，其中n为数据集的大小。
二分查找算法在大规模有序数据集中具有较高的查找效率。
四、哈希查找算法哈希查找算法是一种基于哈希表的查找方法，它通过将待查找元素映射到哈希表中的一个位置，从而快速定位到目标元素。
哈希查找算法的时间复杂度为O(1)，即常数级别。
然而，哈希查找算法对哈希函数的选择和哈希冲突的处理有一定的要求。
如果哈希函数设计不合理或哈希冲突过多，可能会导致查找效率下降。
五、比较与分析在本实验中，我们对上述三种查找算法进行了性能比较和分析。
实验结果表明，在小规模数据集或无序数据集中，顺序查找算法的效率较高；而在大规模有序数据集中，二分查找算法的效率最高。
哈希查找算法虽然具有常数级别的时间复杂度，但在哈希函数和哈希冲突处理上需要额外的开销。
因此，在实际应用中，我们需要根据具体需求选择合适的查找算法。
六、实验总结通过本次实验，我们深入了解了查找算法的原理和应用。
顺序查找算法、二分查找算法和哈希查找算法各具特点，在不同场景下有不同的优劣势。
数据结构实验复习
实验一C语言数据类型的使用[实验目的]复习C语言的使用方法，特别是指针、结构体的内容，同时也为以后的各个实验做准备。
[实验内容及要求]1．建立一个简单链表（静态链表），它由3个学生数据的结点组成，每个结点包括学号和成绩。
输出各结点中的数据。
(根据题目完善程序)#define NULL 0struct student{long num；float score；struct student *next；} stu；typedef struct student stu;main (){ stu a,b,c,*head,*p；a.num=99101；a.score=89.5；b.num=99103；b.score=90；c.num=99107；c.score=85；head=&a；a.next=&b；b.next=&c；c.next=NULL；p=head；do{printf（“%ld%5.1f\n”, ）；/*输出学号和成绩*/p=p->next；}while( )；}输出：2．建立一个动态链表，它由3个学生数据的结点组成，每个结点包括学号和成绩。
输出各结点中的数据。
#define NULL 0#define LEN sizeof(struct student)struct student{long num；float score；struct student *next；}；int n；struct student *creat(void) /*尾插法建立链表*/{struct student *head；struct student *p1, *p2；n=0；p1=p2=(struct student *)malloc(sizeof(struct student))；scanf（“%ld,%f”,&p1->num,&p1->score)；head=NULL；while(p1->num!=0){n=n+1；if (n= =1)head=p1；else p2->next=p1；p2=p2->next ；p1=(struct student *)malloc(LEN)；scanf（“%ld,%f”,&p1->num,&p1->score)；}p2->next=NULL；return( head )；}void print（struct student *head）{struct student *p；printf（“\nNow,These %d records are：\n”,n)；p=head；if(head!=NULL)do{printf（“%ld%5.1f\n”,p->num,p->score)；}while(p!=NULL)；}main(){struct student *head；printf（“input records：\n”）；head=creat()；print(head)；}输入：输出：[思考题]1．将上题链表中学生的成绩从低到高排列输出，要求每行一个，包括学号和成绩。
启发式搜索算法
人工智能基础实验报告实验名称：八数码问题姓名：张俊学号：2220092333指导老师：邓安生启发式搜索算法1. 实验内容：使用启发式搜索算法求解8数码问题。
⑴ 编制程序实现求解8数码问题A *算法，采用估价函数()()()()w n f n d n p n ⎧⎪=+⎨⎪⎩， 其中：()d n 是搜索树中结点n 的深度；()w n 为结点n 的数据库中错放的棋子个数；()p n 为结点n 的数据库中每个棋子与其目标位置之间的距离总和。
⑵ 分析上述⑴中两种估价函数求解8数码问题的效率差别，给出一个是()p n 的上界的()h n 的定义，并测试使用该估价函数是否使算法失去可采纳性。
2. 实验目的熟练掌握启发式搜索A *算法及其可采纳性。
3. 实验原理八数码问题是在3行和3列构成的九宫棋盘上放置数码为1到8的8个棋盘，剩下一个空格的移动来不断改变棋盘的布局，求解这类问题的方法是：给定初始布局（即初始状态）和目标布局（即目标状态），定义操作算子的直观方法是为每个棋牌制定一套可能的走步》上，下，左，右四种移动，再根据所定义的启发式搜索函数在搜索过程中选择最合适的操作算子，得到最优的路径。
4.源代码#include <iomanip> #include <stdlib.h> #include <time.h> #include <iostream> #include <stdio.h> #include <conio.h>#include <math.h>//以上为C++源文件 using namespace std; static int space=0; int target[9];class EightNum//定义一个EightNum 类 {public:int num[9];int f;//初始状态与目标状态相比，棋子错放个数int deap;//深度int evalfun;//状态的估价值EightNum *parent;//以下为类内成员函数的声明EightNum(int nnum[9]);int get_evalfun();int get_deapfun();void eval_func(int id);int Canspread(int n);void Spreadchild(int n);void getnum(int num1[9]);void setnum(int num1[9]);void show(void);int operator ==(EightNum& NewEightN);int operator ==(int num2[9]);int Shownum();};//-----------------------以下为EightNum类成员函数定义-----------------// class Stack{private:EightNum * eightnum;public:Stack * next;EightNum * Minf();EightNum * Belong(EightNum * suc);void Putinto(EightNum * suc);};EightNum::EightNum(int nnum[9]){//此函数功能为：初始化num[]；for(int i=0;i<9;i++)num[i]=nnum[i];f=0;deap=0;parent=NULL;}int EightNum::get_evalfun(){return evalfun;}int EightNum::get_deapfun(){return deap;}void EightNum::eval_func(int id){//此函数为估价函数int i,qifa;qifa=0;switch(id){case 1:{for(i=0;i<9;i++){if(num[i]!=target[i])qifa++;}break;}case 2:{int j, h1,h2;for(i=0;i<9;i++){for(j=0;j<9;j++){if(num[j]==i)h1=j;if(target[j]==i)h2=j;}qifa+=(int)(fabs((double)(h1/3 - h2/3)) + fabs((double)(h1%3 - h2%3)));}break;}case 3:{int j, h1,h2;for(i=0;i<9;i++){for(j=0;j<9;j++){if(num[j]==i)h1=j;if(target[j]==i)h2=j;}qifa+=(int)(fabs((double)(h1/3 - h2/3)) + fabs((double)(h1%3 - h2%3)));}qifa=3*qifa;break;}default :break;}f=qifa;if(this->parent==NULL) deap=0;else deap=this->parent->deap+1;evalfun=deap+f;}int EightNum::Canspread(int n){//判断空格"0"可否移动int i,flag = 0;for(i = 0;i < 9;i++)if(this->num[i] == 0)break;switch(n){case 1:if(i/3 != 0)flag = 1;break;case 2:if(i/3 != 2)flag = 1;break;case 3:if(i%3 != 0)flag = 1;break;case 4:if(i%3 != 2)flag = 1;break;default:break;}return flag ;}void EightNum::Spreadchild(int n){//扩展child节点的子节点int i,loc,qifa;for(i = 0;i < 9;i++)this->num[i] = this->parent->num[i];for(i = 0;i < 9;i++)if(this->num[i] == 0)break;if(n==0)loc = i%3+(i/3 - 1)*3;else if(n==1)loc = i%3+(i/3 + 1)*3;else if(n==2)loc = i%3-1+(i/3)*3;elseloc = i%3+1+(i/3)*3;qifa = this->num[loc];this->num[i] = qifa;this->num[loc] = 0;}void EightNum::getnum(int num1[9]){ for(int i=0;i<9;i++)num1[i]=num[i];}void EightNum::setnum(int num1[9]){ for(int i=0;i<9;i++)num[i]=num1[i];}void EightNum::show(){//输出函数for(int i=0;i<9;i++){cout<<num[i]<<" ";if((i+1)%3==0)cout<<"\n";}cout<<"--------------------";}int EightNum::Shownum(){if(this == NULL)return 0;else{int n = this->parent->Shownum();this->show();cout<<endl;return n+1;}}int EightNum::operator ==(EightNum& NewEightN){int compere=1;for(int i=0;i<9;i++)if(num[i]!=NewEightN.num[i]){compere=0;break;}if(compere==0) return 0;else return 1;}//-----------------------以下为分函数的定义---------------------////判断是否有解的函数int solve(int num[9],int target[9]){int i,j;int num_con=0,tar_con=0;for(i=0;i<9;i++)for(j=0;j<i;j++){if(num[j]<num[i] && num[j]!=0)num_con++;if(target[j]<target[i] && target[j]!=0)tar_con++;}num_con=num_con%2;tar_con=tar_con%2;if((num_con==0 && tar_con==0)||(num_con==1 && tar_con==1))return 1;elsereturn 0;}EightNum * Stack::Minf(){Stack * qifa =this->next;Stack * min = this->next;Stack * minp = this;EightNum * minx;while(qifa->next != NULL){if((qifa->next->eightnum->get_evalfun()) < (min->eightnum->get_evalfun())){min = qifa->next;minp = qifa;}qifa = qifa->next;}minx = min->eightnum;qifa = minp->next;minp->next = minp->next->next;free(qifa);return minx;}//判断节点是否属于OPEN表或CLOSED表EightNum * Stack::Belong(EightNum * suc){Stack * qifa = this-> next ;if(qifa == NULL)return NULL;while(qifa != NULL){if(suc==qifa->eightnum)return qifa ->eightnum;qifa = qifa->next;}return NULL;}//把节点存入OPEN 或CLOSED 表中void Stack::Putinto(EightNum * suc){Stack * qifa;qifa =(Stack *) malloc(sizeof(Stack));qifa->eightnum = suc;qifa->next = this->next;this->next = qifa;}int BelongProgram(EightNum * suc ,Stack *Open ,Stack *Closed ,EightNum goal,int m ){EightNum * qifa = NULL;int flag = 0;if((Open->Belong(suc) != NULL) || (Closed->Belong(suc) != NULL)){if(Open->Belong(suc) != NULL) qifa = Open->Belong(suc);else qifa = Closed->Belong(suc);flag=1;}else{Open->Putinto(suc);suc->eval_func(m);}return flag;}//扩展后继节点总函数void Spread(EightNum * suc, Stack * Open, Stack * Closed, EightNum goal,int m){int i;EightNum * child;for(i = 0; i < 4; i++){if(suc->Canspread(i+1)){space++;child = (EightNum *) malloc(sizeof(EightNum));child->parent = suc;child->Spreadchild(i);child->eval_func(m);if(BelongProgram(child, Open, Closed, goal,m)) //判断子节点是否属于OPEN或CLOSED表free(child);}}}//执行函数EightNum * Process(EightNum * org, EightNum goal, Stack * Open, Stack * Closed,int m){while(1){if(Open->next == NULL)return NULL;EightNum * minf =Open->Minf();Closed->Putinto(minf);if((*minf)==goal)return minf;Spread(minf, Open, Closed, goal,m);}}//------------------------A*算法搜索函数----------------------//void A(int id,EightNum start,EightNum Target){EightNum * result;space=0;float time;Stack *Open = (Stack *) malloc(sizeof(Stack));Open->next = NULL;Stack *Closed = (Stack *) malloc(sizeof(Stack));Closed->next = NULL;clock_t startt,finisht;startt=clock();//开始时间start.eval_func(id);Open->Putinto(&start);result = Process(&start, Target, Open, Closed,id); //进行剩余的操作cout<<"\n搜索过程:\n"<<result->Shownum()<<endl;finisht=clock();time=(float)(finisht-startt);cout<<endl<<id<<"算法处理结果：所耗时间:";cout<<time;cout<<"ms, ";cout<<"所耗空间:";cout<<space;cout<<"块, "<<endl<<endl;}//-----------------------------主函数-----------------------------//int main(void)//主函数{int i,j;int flag;int num[9];int error;do{error=0;cout<<"请输入八数码问题的初始状态(0代表空格,“棋子”间用空格隔开):"<<endl;for(i=0;i<9;i++){flag=0;cin>>num[i];for(j=0;j<i;j++)if(num[j]==num[i])flag=1;if(num[i]<0||num[i]>8||flag==1){error++;}}if(error!=0)cout<<"输入数据错误!请重新输入!"<<endl;}while(error!=0);//输入八数码问题的初始状态(0代表空格,“棋子”间用空格隔开）；int error1;do{error1=0;cout<<"请输入新的目标状态(用0代表空格,“棋子”间用空格隔开):"<<endl;for(i=0;i<9;i++){flag=0;cin>>target[i];for(j=0;j<i;j++)if(target[j]==target[i])flag=1;if(target[i]<0||target[i]>9||flag==1){error1++;}}if(error1!=0)cout<<"输入数据错误!请重新输入!"<<endl;}while(error1!=0);//输入八数码问题的目标状态(用0代表空格,中间用空格隔开）；EightNum start(num),Target(target);int m=solve(num,target);//判断初始状态到目标状态是否有解，有解返回1，误解返回0；if(m==0){cout<<"此状态无解!"<<endl;return 0;}int id=0;while(id!=3){cout<<"1. 错放的棋子个数为;\n2.每个棋子与目标位置之间的距离总和为;"<<endl;cout<<"3.结束，退出程序！"<<endl;cout<<"\n请选择功能,分别输入“1”“2”“3”进行选择："<<endl;cin>>id;switch(id){case 1:{cout<<"错放的棋子个数结果为:\n(以下逐一展示搜索过程：)"<<endl;A(1,start,Target);break;}case 2:{cout<<"每个棋子与其目标位置之间的距离总和为:\n(以下逐一展示搜索过程：)"<<endl;A(2,start,Target);break;}default: break;}}cout<<"啊啊….程序结束!!";}实验截图实验中遇到的问题1：开始程序只能运行一种方式即按照错位个数搜索，后经过查找相关资料，修改后可程序可进行选择，两种方法结合在一起根据选择运行。
数据结构查找算法实验报告
数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法，包括顺序查找、二分查找、哈希查找等，并通过实际编程实现和性能分析，比较它们在不同数据规模和分布情况下的效率和优劣。
二、实验环境操作系统：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 秒|从结果可以看出，在数据规模较小时，顺序查找和哈希查找的性能差距不大，二分查找由于需要先对数据进行排序，所以优势不明显。
数据查找实验报告
实验名称：数据查找实验实验日期：2023年3月15日实验地点：计算机实验室实验人员：张三、李四一、实验目的1. 熟悉并掌握数据查找的基本方法。
2. 了解不同查找算法的优缺点。
3. 提高数据查找的效率。
二、实验内容1. 数据准备：准备一组随机生成的整数数据，共计1000个，范围在1到10000之间。
2. 数据存储：将生成的数据存储在一个文本文件中，每个数字占一行。
3. 数据查找方法：（1）顺序查找法（2）二分查找法（3）哈希查找法4. 实验对比：对三种查找方法进行对比，分析其查找效率。
三、实验步骤1. 编写程序生成随机整数数据，并存储到文本文件中。
2. 编写顺序查找法程序，实现查找功能。
3. 编写二分查找法程序，实现查找功能。
4. 编写哈希查找法程序，实现查找功能。
5. 对比三种查找方法的执行时间。
四、实验结果与分析1. 顺序查找法顺序查找法是一种最简单的查找方法，其基本思想是从数组的第一个元素开始，依次将元素与要查找的值进行比较，直到找到目标值或查遍整个数组。
实验结果显示，顺序查找法的查找效率较低，当数据量较大时，执行时间较长。
2. 二分查找法二分查找法是一种高效的查找方法，其基本思想是将数组分为两部分，根据要查找的值与中间元素的大小关系，确定目标值在数组的哪一半，然后在那一半中继续查找，直到找到目标值或查遍整个数组。
实验结果显示，二分查找法的查找效率较高，当数据量较大时，执行时间较短。
3. 哈希查找法哈希查找法是一种基于哈希函数的查找方法，其基本思想是使用哈希函数将待查找的值映射到哈希表中，然后在哈希表中查找目标值。
实验结果显示，哈希查找法的查找效率最高，当数据量较大时，执行时间最短。
五、实验结论1. 顺序查找法适用于数据量较小的场景，当数据量较大时，查找效率较低。
2. 二分查找法适用于数据量较大的场景，查找效率较高。
3. 哈希查找法在数据量较大时，查找效率最高，但需要考虑哈希冲突的问题。
六、实验心得通过本次实验，我们对数据查找方法有了更深入的了解，掌握了顺序查找法、二分查找法和哈希查找法的基本原理和实现方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告八查找算法实现实验班级： 2009053 姓名：汤冬劼学号：20091776 专业：一、实验目的：1、熟悉线性查找算法。
2、掌握顺序查找、二分查找算法3、熟悉非线性查找算法。
3、掌握二叉排序树操作算法。
二、实验内容：[实现提示] （同时可参见教材及ppt上的算法）函数、类名称等可自定义，部分变量请加上学号后3位。
也可自行对类中所定义的操作进行扩展。
所加载的库函数或常量定义及类的定义：#include<iostream>using namespace std;template <class T1,class T2> class seqlist;template <class T1,class T2>class elem{friend class seqlist<T1,T2>;T1 key;T2 other;};template <class T1,class T2>class seqlist{public:seqlist(int n1,T1 a[ ]);int seqcheck(int k);private:elem<T1,T2> *data;int n;};1、存储结构类定义与实现：自定义如下：template<class T1,class T2>seqlist<T1,T2>::seqlist(int n1,T1 a[ ]){data=new elem<T1,T2>[n1];for(int i=0;i<n1;i++)data[i].key=a[i];n=n1;}2、顺序查找算法[实现提示] （同时可参见教材算法）顺序查找算法实现如下：template <class T1,class T2>int seqlist<T1,T2>::seqcheck(int k){int i=n;data[0].key=k;//哨兵while (data[i].key!=k)i--;return i;}测试结果粘贴如下：3、有序表的二分查找（折半查找）[实现提示] （同时可参见教材算法）库函数和常量定义：#include<iostream>using namespace std;template <class T1,class T2> class seqlist; template <class T1,class T2>class elem{friend class seqlist<T1,T2>;T1 key;T2 other;};template <class T1,class T2>class seqlist{public:seqlist(int n1,T1 a[ ]);int seqcheck(int k);int rfcz(int k);private:elem<T1,T2> *data;int n;};（1）存储结构定义：自定义如下：（可自已定义）template<class T1,class T2>seqlist<T1,T2>::seqlist(int n1,T1 a[ ]){data=new elem<T1,T2>[n1];for(int i=0;i<n1;i++)data[i].key=a[i];n=n1;}（2）二分查找算法template <class T1,class T2>int seqlist<T1,T2>::rfcz(int k){//二分查找算法int low,high,mid;for(low=1,high=n;low<=high;){mid=(low+high)/2;if(k==data[mid].key) return mid;else if(k<data[mid].key) high=mid-1;else low=mid+1;}return 0;}测试结果粘贴如下：4、二叉排序树的操作算法[实现提示] （同时可参见教材算法）（1）二叉排序树的查找算法（2）二叉排序树的插入算法#include<iostream>using namespace std;template <class T> class BiSortTree; template <class T>class BiNode //二叉树的结点结构{friend class BiSortTree<T>;T data;BiNode<T> *lchild, *rchild;};template <class T>class BiSortTree //假定记录中只有一个整型数据项{public:BiSortTree(T a[ ],int n);~BiSortTree();BiNode<T>*InsertTree(BiNode<T> *p,BiNode<T> *s);void chazhao(T k,BiNode<T> *p);void find(T k);private:BiNode<T> *root;void Release(BiNode<T> *p);};template<class T>BiSortTree<T>::BiSortTree(T a[ ],int n){root=new BiNode<T>;BiNode<T> *m;root->data=a[0];root->lchild=NULL;root->rchild=NULL;for(int i=1;i<n;i++){m=new BiNode<T>;m->data=a[i];m->rchild=NULL;m->lchild=NULL;InsertTree(root,m);}}template <class T>BiNode<T>* BiSortTree<T>::InsertTree(BiNode<T> *p, BiNode<T> *s) {if(p==NULL) return s;else{if(s->data>p->data)p->rchild=InsertTree(p->rchild, s);elsep->lchild=InsertTree(p->lchild, s);return p;}}template<class T>void BiSortTree<T>::chazhao(T k,BiNode<T> *p) {if(p==NULL){BiNode<T> *s;s=new BiNode<T>;s->data=k;s->rchild=NULL;s->lchild=NULL;p=s;cout<<"以添加"<<endl;}else{if(k<p->data)chazhao(k,p->lchild);if(k>p->data)chazhao(k,p->rchild);if(k==p->data)cout<<"找到了"<<endl;}}template<class T>void BiSortTree<T>::find(T k){chazhao(k,root);}template<class T>void BiSortTree<T>::Release(BiNode<T> *p) {if(p!=NULL){if(p->lchild==NULL&&p->rchild==NULL) delete p;else{Release(p->lchild);Release(p->rchild);}}}template<class T>BiSortTree<T>::~BiSortTree(){Release(root);}int main(){int b[7]={10,8,13,6,9,12,15};BiSortTree<int> tree(b,7);tree.find(5);return 0;}测试结果粘贴如下：选做：试写有序表的分块查找算法和二叉排序树的删除算法。
#include<iostream>using namespace std;template <class T1,class T2> class seqlist;template <class T1,class T2>class elem{friend class seqlist<T1,T2>;T1 key;T2 other;};template <class T1,class T2>class seqlist{public:seqlist(int n1,T1 a[ ]);int chazhao(T1 k);private:elem<T1,T2> *data;elem<T1,T2> *data1;int n;};template<class T1,class T2>seqlist<T1,T2>::seqlist(int n1,T1 a[ ]){data=new elem<T1,T2>[n1];paixu(n1,a);for(int i=0;i<n1;i++)data[i].key=a[i];n=n1;data1=new elem<T1,T2>[n1/2+1]; for(i=0;2*i+1<n1;i++){data1[i].key=data[2*i+1].key; data1[i].other=2*i;}data1[n/2].key=data[n-1].key;data1[n/2].other=n-1;}template<class T1>void paixu(int n1,T1 a[ ]){T1 min=a[0];for(int i=0;i<n1;i++)for(int j=i+1;j<n1;j++)if(min>a[j]){min=a[j];a[i]=a[j];}}template<class T1,class T2>int seqlist<T1,T2>::chazhao(T1 k) {int i=0,j;while(data1[i].key<k&&i<n/2+1) i++;if(i==n/2+1)return 0;else{j=data1[i].other;if(j==n-1)return 0;for(int k1=0;k1<2;k1++){if(data[j].key==k)return j;j++;}return 0;}}int main(){int b[5]={1,2,3,4,5};seqlist<int,int>cha(5,b);cout<<cha.chazhao(3)<<endl;return 0;}#include<iostream>using namespace std;template <class T> class BiSortTree;template <class T>class BiNode //二叉树的结点结构{friend class BiSortTree<T>;T data;BiNode<T> *lchild, *rchild,*parent;};template <class T>class BiSortTree //假定记录中只有一个整型数据项{public:BiSortTree(T a[ ],int n);~BiSortTree();BiNode<T>*InsertTree(BiNode<T> *p,BiNode<T> *s);void chazhao(T k,BiNode<T> *p);void find(T k);void display();private:BiNode<T> *root;void Release(BiNode<T> *p);void dDLR(BiNode<T> *rt);};template<class T>BiSortTree<T>::BiSortTree(T a[ ],int n){root=new BiNode<T>;BiNode<T> *m;root->data=a[0];root->lchild=NULL;root->rchild=NULL;for(int i=1;i<n;i++){m=new BiNode<T>;m->data=a[i];m->rchild=NULL;m->lchild=NULL;InsertTree(root,m);}}template <class T>BiNode<T>* BiSortTree<T>::InsertTree(BiNode<T> *p, BiNode<T> *s) {if(p==NULL) return s;else{if(s->data>p->data){p->rchild=InsertTree(p->rchild, s);p->rchild->parent=p;}else{p->lchild=InsertTree(p->lchild, s);p->lchild->parent=p;}return p;}}template<class T>void BiSortTree<T>::chazhao(T k,BiNode<T> *p){BiNode<T> *q;int i=0;if(p==NULL)cout<<"无此结点"<<endl;else{if(k<p->data)chazhao(k,p->lchild);if(k>p->data)chazhao(k,p->rchild);if(k==p->data){if(p->rchild==NULL){if(p->rchild==NULL&&p->lchild==NULL) {if(p->parent->rchild==p)p->parent->rchild=NULL;elsep->parent->lchild=NULL;delete p;}if(p->lchild!=NULL&&p->rchild==NULL) {if(p->parent->rchild==p)p->parent->rchild=p->lchild;elsep->parent->lchild=p->lchild;delete p;}}else{if(p->lchild==NULL){if(p->parent->rchild==p)p->parent->rchild=p->rchild;elsep->parent->lchild=p->rchild;delete p;}elseif(p->lchild!=NULL){q=p->lchild;while(q->rchild!=NULL){q=q->rchild;i++;}if(i==0)q->parent->lchild=NULL;elseq->parent->rchild=NULL;q->lchild=p->lchild;q->rchild=p->rchild;q->parent=p->parent;if(p!=root){if(p->parent->lchild==p)p->parent->lchild=q;elsep->parent->rchild=q;}elseroot=q;delete p;}}}}}template <class T>void BiSortTree<T>::dDLR(BiNode<T> *rt) {if (rt){cout<<rt->data<<ends;dDLR(rt->lchild);dDLR(rt->rchild);}}template<class T>void BiSortTree<T>::find(T k){chazhao(k,root);}template<class T>void BiSortTree<T>::Release(BiNode<T> *p) {if(p!=NULL){if(p->lchild==NULL&&p->rchild==NULL) delete p;else{Release(p->lchild);Release(p->rchild);}}}template<class T>BiSortTree<T>::~BiSortTree(){Release(root);}template<class T>void BiSortTree<T>::display(){dDLR(root);}int main(){int b[8]={10,8,13,6,9,12,15,16};BiSortTree<int> tree(b,8);tree.find(16);tree.display();return 0;}三、实验心得（含上机中所遇问题的解决办法，所使用到的编程技巧、创新点及编程的心得）。