《数据结构》实验报告查找
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告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、实验目的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 定义二分查找函数,接受有序数组、要查找的关键字以及数组的起始和结束索引作为参数。
数据结构与算法实验报告5-查找与排序
北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法;
2.了解树表查找思想;
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法;
二、实验内容
查找部分
1.实现顺序查找的两个算法(P307), 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果;
2.实现对有序表的二分查找;
3.实现散列查找算法(链接法),应能够解决冲突;
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
(描述实验步骤及中间的结果或现象。
在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落)
五、实验结果
六、总结
(说明实验过程中遇到的问题及解决办法;个人的收获;未解决的问题等)。
数据结构实验报告—搜索结构
《算法与数据结构》课程实验报告一、实验目的应用线性结构、树形结构实现搜索结构。
二、实验内容及要求1、有序顺序表的折半搜索(1)随机产生1000个整数(要求互不相同)存储于顺序表中(2)将顺序表变为有序顺序表(3)使用折半搜索方法实现搜索,计算平均搜索长度的2、二叉搜索树的查找(1)使用二叉链表创建二叉搜索树,数据元素仍使用随机数(1000个)(2)实现二叉树的插入、删除算法(3)实现搜索算法,计算平均搜索长度的值三、系统分析(1)数据方面:该实验在实现线性结构、树形结构实现搜索结构时采用数据均为整型,并约定-1为结束标识符。
在此基础上进行搜索相关操作。
(2)功能方面:针对线性结构、树形结构实现不同功能,包括以下几点:1、顺序表的搜索(1)能够实现产生指定数量、指定数据大小范围的不同的整形随机数。
(2)能够对所产生数据通过冒泡排序法进行排序。
(3)能够对顺序表数据利用顺序搜索进行搜索。
(4)能够利用迭代法、递归法两种不同方法进行折半搜索。
2、二叉搜索树的搜索(1)能够实现产生指定数量、指定数据大小范围的不同的整形随机数。
(2)能够对所产生数据建立二叉搜索树。
(3)能够对二叉搜索树前序遍历输出。
(4)能够在建立二叉搜索树基础上插入数据。
(5)能够在建立二叉搜索树基础上删除数据。
(6)能够在建立二叉搜索树基础上搜索数据。
(7)能够计算二叉搜索树平均检索长度(ASL)。
四、系统设计(1)设计的主要思路线性结构与树形结构在之前的实验中都有所完成,故基于这两种存储结构的搜索结构只需实现实验要求的顺序搜索、折半搜索、计算平均检索长度即可。
由于涉及两种结构的搜索实现,故分别设计两个菜单实现两种不同的搜索结构。
(2)数据结构的设计线性结构实现搜索结构,即将数据对象放于数组中,利用数组元素的下标作为数据对象的存放地址。
搜索算法根据给定需要搜索的数值,在数组中进行搜索。
直到找到该数值在数组中存放的位置或可确定数值不存在于数组中。
数据结构查找实验报告
一、实验目的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.理解掌握查找与排序在计算机中的各种实现方法。
2.学会针对所给问题选用最适合的算法。
3.熟练掌握常用排序算法在顺序表上的实现。
二、实验要求:掌握利用常用的查找排序算法的思想来解决一般问题的方法和技巧,进行算法分析并写出实习报告。
三、实验内容及分析:设计一个学生信息管理系统,学生对象至少要包含:学号、性别、成绩1、成绩总成绩等信息。
要求实现以下功能:1.平均成绩要求自动计算;2.查找:分别给定学生学号、性别,能够查找到学生的基本信息(要求至少用两种查找算法实现);3.? 排序:分别按学生的学号、成绩1、成绩2、平均成绩进行排序(要求至少用两种排序算法实现)。
四、程序的调试及运行结果五、程序代码#includestdio.h#includestring.hstruct student//定义结构体{char name;int a1,a2,a3,num;double pow;}zl;int count=0;void jiemian1(); //主界面//函数声明int jiemian2(); //选择界面void luru(); //录入函数void xianshi(); //显示void paixv(); //排序void diaoyong(int); //循环调用选择界面void tianjia(); //添加信息void chaxun1(); //按学号查询详细信息void chaxun2(); //按姓名查询详细信息void xiugai(); //修改信息void shanchu(); //删除信息void main() //main函数{jiemian1();//函数点用}void jiemian1() //主界面定义{char a;printf(“\n\n\n\n\t\t\t学员信息管理器\n\n\n\t\t\t 数据结构课程设计练习六\n\n\n\t\t\t 09信计2:于学彬\n\n“);printf("\n\t\t\t 按回车键继续:");scanf("%c",system("cls");jiemian2();}int jiemian2() //选择界面{int a,b;printf("*******************************主要功能********************************");printf("\n\n\n\n\t\t\t\t1.录入信息\n\n\t\t\t\t2.添加信息\n\n\t\t\t\t3.查看信息\n\n\t\t\t\t4.查询信息\n\n\t\t\t\t5.修改信息\n\n\t\t\t\t6.删除信息\n\n\t\t\t\t7.退出\n\n\t\t\t\t请选择:");scanf("%d",switch(a){case 1:system("cls");luru();break;case 2:system("cls");tianjia();break;case 3:system("cls");paixv();break;case 4:system("cls");printf("1.按学号查询详细信息\n2.按姓名查询详细信息\n请选择:");scanf("%d",switch(b){case 1:system("cls");chaxun1();break;case 2:system("cls");chaxun2();break;} break;case 5:system("cls");xiugai();break;case 6:system("cls");shanchu();break;case 7:system("cls");return a;break;}}void diaoyong(int b) //循环调用选择界面{char a='y';printf("是否返回选择页(y/n):");fflush(stdin);//清空输入缓冲区,通常是为了确保不影响后面的数据读取(例如在读完一个字符串后紧接着又要读取一个字符,此时应该先执行fflush(stdin);)a=getchar();system("cls");while(a=='y'||a=='Y'){b=jiemian2();if(b==7){break;}}}void luru() //录入函数{char a;//='y';do{printf("请输入学员信息:\n");printf("学号:");scanf("%d",zl[count].num);//调用结构体printf("姓名:");fflush(stdin);gets(zl[count].name);printf("三门成绩:\n");printf("成绩1:");scanf("%d",zl[count].a1);printf("成绩2:");scanf("%d",zl[count].a2);printf("成绩3:");scanf("%d",zl[count].a3);zl[count].pow=(zl[count].a1+zl[count].a2+zl[count].a3)/3;//求平均数printf("是否继续(y/n):");fflush(stdin);a=getchar();count++;system("cls");}while(a=='y'count100);//paixv();diaoyong(count);}void tianjia() //添加信息{char a='y';do{printf("请输入学员信息:\n");printf("学号:");scanf("%d",zl[count].num);printf("姓名:");//fflush(stdin);gets(zl[count].name);printf("三门成绩:\n");printf("成绩1:");scanf("%d",zl[count].a1);printf("成绩2:");scanf("%d",zl[count].a2);printf("成绩3:");scanf("%d",zl[count].a3);zl[count].pow=(zl[count].a1+zl[count].a2+zl[count].a3)/3; printf("是否继续(y/n):");//fflush(stdin);a=getchar();count++;system("cls");}while(a=='y'count100);paixv(count);diaoyong(count);}void xianshi() //显示{int i;printf("学号\t \t姓名\t\t\t平均成绩\n");for(i=0;icount;i++){printf("%d\t \t%s\t\t\t%f\n",zl[i].num,zl[i].name,zl[i].pow); }}void paixv() //排序{int i,j;struct student zl1;printf("排序前:\n");xianshi();for(i=0;icount;i++){for(j=1;jcount-i;j++){if(zl[j-1].powzl[j].pow){zl1=zl[j-1];zl[j-1]=zl[j];zl[j]=zl1;}}}printf("排序后:\n");xianshi();diaoyong(count);}void chaxun1() //按学号查询详细信息{int i,num;printf("请输入要查询学员的学号:");scanf("%d",num);printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n"); for(i=0;icount;i++){if(zl[i].num==num){printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl [i].a3,zl[i].pow);}}diaoyong(count);}void chaxun2() //按姓名查询详细信息{int i;struct student zl1;printf("请输入要查询学员的姓名:");fflush(stdin);gets();printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n");for(i=0;icount;i++){if((strcmp(zl[i].name,))==0)//比较两个字符串的大小{printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl [i].a3,zl[i].pow);}}diaoyong(count);}void xiugai() //修改信息{int i,num;printf("请输入要查询学员的学号:");scanf("%d",num);printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n");for(i=0;icount;i++){if(zl[i].num==num){break;}}printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl [i].a3,zl[i].pow);printf("请输入学员信息:\n");printf("学号:");scanf("%d",zl[i].num);printf("姓名:");fflush(stdin);gets(zl[i].name);printf("三门成绩:\n");printf("成绩1:");scanf("%d",zl[i].a1);printf("成绩2:");scanf("%d",zl[i].a2);printf("成绩3:");scanf("%d",zl[i].a3);zl[i].pow=(zl[i].a1+zl[i].a2+zl[i].a3)/3;printf("学号\t姓名\t成绩1\t成绩2\t成绩3\t平均成绩\n"); printf("%d\t%s\t%d\t%d\t%d\t%.2f\n",zl[i].num,zl[i].name,zl[i].a1,zl[i].a2,zl[i].a3,zl[i].pow);diaoyong(count);}void shanchu() //删除信息{int num,i,j;printf("请输入要删除的学员学号:");scanf("%d",num);for(i=0;icount;i++){if(zl[i].num==num){for(j=i;jcount;j++){zl[j]=zl[j+1];}}}count--;xianshi();diaoyong(count);}。
数据结构实验报告-静态查找表中的查找
数据结构实验报告-静态查找表中的查找第一篇:数据结构实验报告-静态查找表中的查找数据结构实验实验一静态查找表中的查找一、实验目的:1、理解静态查找表的概念2、掌握顺序查找和折半查找算法及其实现方法3、理解顺序查找和折半查找的特点,学会分析算法的性能二、实验内容:1、按关键字从小到大顺序输入一组记录构造查找表,并且输出该查找表;2、给定一个关键字值,对所构造的查找表分别进行顺序查找和折半查找,输出查找的结果以及查找过程中“比较”操作的执行次数。
三、实验要求:1、查找表的长度、查找表中的记录和待查找的关键字值要从终端输入;2、具体的输入和输出格式不限;3、算法要具有较好的健壮性,对错误操作要做适当处理;4、输出信息中要标明所采用的查找方法类型。
实验二基于二叉排序树的查找一、实验目的:1、理解动态查找表和二叉排序树的概念2、掌握二叉排序树的构造算法及其实现方法3、掌握二叉排序树的查找算法及其实现方法二、实验内容:1、输入一组记录构造一颗二叉排序树,并且输出这棵二叉排序树的中序序列;2、给定一个关键字值,对所构造的二叉排序树进行查找,并输出查找的结果。
三、实验要求:1、二叉排序树中的记录和待查找的关键字值要从终端输入;2、输入的记录格式为(整数,序号),例如(3, 2)表示关键字值为3,输入序号为2的记录;3、算法要具有较好的健壮性,对错误操作要做适当处理。
四、程序实现:(1)实现顺序查找表和折半查找表:#include #define MAX_LENGTH 100 typedef struct {int key[MAX_LENGTH];int length;}stable;int seqserch(stable ST,int key,int &count){int i;for(i=ST.length;i>0;i--){count++;if(ST.key[i]==key)return i;}return 0;}int binserch(stable ST,int key,int &count){int low=1,high=ST.length,mid;while(low<=high){count++;mid=(low+high)/2;if(ST.key[mid]==key)return mid;else if(keyhigh=mid-1;elselow=mid+1;}return 0;}main(){stable ST1;inta,b,k,x,count1=0,count2=0,temp=0;ST1.length=0;printf(“请按从小到大的顺序输入查找表数据:(-1代表结束!)n”);for(a=0;a{s canf(“%d”,&temp);if(temp!=-1){ST1.key[a]=temp;ST1.length++;}elsebreak;}printf(“输入数据为:n”);for(b=0;b{printf(“%d ”,ST1.key[b]);}printf(“n请输入要查找的数据:”);scanf(“%d”,&k);a=seqserch(ST1,k,count1)+1;printf(“n顺序查找:该数据的位置在第:%d个n”,a);printf(“查找次数为:%dnn”,count1-1);a=binserch(ST1,k,count2)+1;printf(“折半查找:该数据的位置在第:%d个n”,a);printf(“查找次数为:%dn”,count2-1);}(2)二叉排序树的查找:#include #includetypedef struct node {int data;int key;struct node *left,*right;}bitnode,*bittree;void serchbst(bittree T,bittree *F,bittree *C,int data){while(T!=NULL){if(T->data==data){*C=T;break;}else if(datadata){*F=T;T=T->left;}else{*F=T;T=T->right;}}return 0;}int insertbst(bittree *T,int key,int data){bittree F=NULL,C=NULL,s;serchbst(*T,&F,&C,data);if(C!=NULL)return 0;s=(bittree)malloc(sizeof(bitnode));s->data=data;s->key=key;s->left=s->right=NULL;if(F==NULL)*T=s;else if(datadata)F->left=s;elseF->right=s;return 1;}void creatbst(bittree *T){int key,data;*T=NULL;printf(“请输入数据以构造二叉排序树:(数据格式为:m n(-1000,-1000)代表结束)n”);scanf(“%d%d”,&key,&data);while(key!=-1000 || data!=-1000){insertbst(T,key,data);scanf(“%d%d”,&key,&data);} }void midTraverse(bittree T){if(T!=NULL){midTraverse(T->left);printf(“(%d,%d)”,T->key,T->data);midTraverse(T->right);} }main(){bittreeT=NULL,C=NULL,F=NULL;int key,data,temp;creatbst(&T);printf(“此二叉树的中序序列为:”);midTraverse(T);printf(“n请输入要查找的关键字:”);scanf(“%d”,&data);serchbst(T,&F,&C,data);printf(“此关键字的数据为:%dn”,C->key);}五、实现结果:(1)顺序查找和折半查找:(2)二叉树排序树查找:六、实验之心得体会:(1)在这次实验中,我基本上掌握了顺序查找、折半查找和二叉排序树查找的基本思想和实现方法,让我体会到了写程序时,不仅要考虑是否能够调试出结果,还要考虑程序实现的效率,这是一个编程人员必须要具备的一项总要的素质。
数据结构查找算法实验报告
数据结构实验报告实验第四章:实验:简单查找算法一.需求与规格说明:查找算法这里主要使用了顺序查找,折半查找,二叉排序树查找与哈希表查找四种方法。
由于自己能力有限,本想实现其她算法,但没有实现.其中顺序查找相对比较简单,折半查找参考了书上得算法,二叉排序树查找由于有之前做二叉树得经验,因此实现得较为顺利,哈希表感觉做得并不成功,感觉还就是应该可以进一步完善,应该说还有很大得改进余地。
二.设计思想:开始得时候提示输入一组数据。
并存入一维数组中,接下来调用一系列查找算法对其进行处理。
顺序查找只就是从头到尾进行遍历。
二分查找则就是先对数据进行排序,然后利用三个标志,分别指向最大,中间与最小数据,接下来根据待查找数据与中间数据得比较不断移动标志,直至找到。
二叉排序树则就是先构造,构造部分花费最多得精力,比根节点数据大得结点放入根节点得右子树,比根节点数据小得放入根节点得左子树,其实完全可以利用递归实现,这里使用得循环来实现得,感觉这里可以尝试用递归.当二叉树建好后,中序遍历序列即为由小到大得有序序列,查找次数不会超过二叉树得深度。
这里还使用了广义表输出二叉树,以使得更直观。
哈希表则就是利用给定得函数式建立索引,方便查找.三.设计表示:四.实现注释:其实查找排序这部分与前面得一些知识联系得比较紧密,例如顺序表得建立与实现,顺序表节点得排序,二叉树得生成与遍历,这里主要就是中序遍历.应该说有些知识点较为熟悉,但在实现得时候并不就是那么顺利。
在查找到数据得时候要想办法输出查找过程得相关信息,并统计。
这里顺序查找与折半查找均使用了数组存储得顺序表,而二叉树则就是采用了链表存储得树形结构。
为了直观起见,在用户输入了数据后,分别输出已经生成得数组与树。
折半查找由于只能查找有序表,因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计.二叉排序树应该说由于有了之前二叉树得基础,并没有费太大力气,主要就是在构造二叉树得时候,要对新加入得节点数据与跟数据进行比较,如果比根节点数据大则放在右子树里,如果比根节点数据小则放入左子树。
数据结构-查找-实验报告
实验报告实验八查找一、实验目的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.掌握二叉排序树的查找算法。
二、实验内容1.建立一个顺序表,用顺序查找的方法对其实施查找;2.建立一个有序表,用折半查找的方法对其实施查找;3.建立一个二叉排序树,根据给定值对其实施查找;4.对同一组数据,试用三种方法查找某一相同数据,并尝试进行性能分析。
三、实验预习内容实验一包括的函数有:typedef struct ,创建函数void create(seqlist & L),输出函数void print(seqlist L),顺序查找int find(seqlist L,int number),折半查找int halffind(seqlist L,int number)主函数main().实验二包括的函数有:结构体typedef struct,插入函数void insert(bnode * & T,bnode * S),void insert1(bnode * & T),创建函数void create(bnode * & T),查找函数bnode * search(bnode * T,int number),主函数main().四、上机实验实验一:1.实验源程序。
#include<>#define N 80typedef struct{int number; umber;for(i=1;[i].number!=0;){cin>>[i].name>>[i].sex>>[i].age;++;cout<<endl;cin>>[++i].number;}}umber<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;}umber==number)return i;}umber)return mid;elseif(number<[mid].number)high=mid-1;elselow=mid+1;}return 0;}void main(){int i,number;seqlist L;create(L);print(L);cout<<"折半查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=halffind(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;cout<<"顺序查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=find(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;}实验二:#include<>typedef struct{int number; 立二叉排序树"<<"\n\t2.插入学生信息"<<"\n\t3.查找学生信息"<<endl;cout<<"选择:";cin>>choice;switch(choice){case 1:{create(T);cout<<"成功建立!"<<endl;};break;case 2:{insert1(T);cout<<"插入成功!"<<endl;};break;case 3:{cout<<"输入待查学生的学号:";cin>>number;p=search(T,number);if(p)cout<<p-><<"\t"<<p-><<"\t"<<p-><<"\t"<<p-><<endl;elsecout<<"查找失败!"<<endl;};break;}cout<<"Continue(Y/N):";cin>>ctinue;if(ctinue=='y'||ctinue=='y')flag=1;elseflag=0;}}2.实验结果(截图)。
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告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.掌握顺序查找操作的算法实现。
二、实验平台操作系统:Windows7或Windows XP开发环境:JA V A三、实验内容及要求1.建立顺序查找表,并在此查找表上实现顺序查找操作。
四、实验的软硬件环境要求硬件环境要求:PC机(单机)使用的软件名称、版本号以及模块:Netbeans 6.5以上或Eclipse、MyEclipse等编程环境下。
五、知识准备前期要求掌握查找的含义和顺序查找操作的方法。
六、验证性实验1.实验要求编程实现如下功能:(1)根据输入的查找表的表长n和n个关键字值,建立顺序查找表,并在此查找表中用顺序查找方法查找给定关键值的记录,最后输出查找结果。
2. 实验相关原理:查找表分别静态查找表和动态查找表两种,其中只能做引用操作的查找表称为静态查找表。
静态查找表采用顺序存储结构,待查找的记录类可描述如下:public class RecordNode {private Comparable key; //关键字private Object element; //数据元素……}待排序的顺序表类描述如下:public class SeqList {private RecordNode[] r; //顺序表记录结点数组private int curlen; //顺序表长度,即记录个数// 顺序表的构造方法,构造一个存储空间容量为maxSize的顺序表public SeqList(int maxSize) {this.r = new RecordNode[maxSize]; // 为顺序表分配maxSize个存储单元this.curlen = 0; // 置顺序表的当前长度为0}……}【核心算法提示】查找操作是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素或记录的过程。
若查找表中存在这样一个记录,则称“查找成功”。
查找结果给出整个记录的信息,或指示该记录在查找表中的位置;若在查找表中不存在这样的记录,则称“查找不成功”。
数据结构查找实验报告
数据结构查找实验报告数据结构查找实验报告一、引言数据结构是计算机科学中的重要概念之一,它涉及到组织和管理数据的方式和方法。
在实际应用中,我们经常需要对大量的数据进行查找操作,因此查找算法的效率和准确性显得尤为重要。
本实验旨在通过对比不同的查找算法,探索其性能和适用场景。
二、实验目的本实验的目的是比较常见的查找算法,包括线性查找、二分查找和哈希查找,分析它们的时间复杂度和空间复杂度,并通过实验数据验证其效率。
三、实验方法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. 实验结果通过多次实验,我们得到了不同查找算法的平均查找时间。
数据结构查找算法实验报告
数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法,包括顺序查找、二分查找、哈希查找等,并通过实际编程实现和性能分析,比较它们在不同数据规模和分布情况下的效率和优劣。
二、实验环境操作系统: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 秒|从结果可以看出,在数据规模较小时,顺序查找和哈希查找的性能差距不大,二分查找由于需要先对数据进行排序,所以优势不明显。
《数据结构》实验报告三:几种查找算法的实现和比较
第三次实验报告:几种查找算法的实现和比较//2019-12-4//1.随机生成5万个整数,存入一个文件;//2.算法实现:(1)顺序查找:读入文件中的数据,查找一个key,统计时间;// (2)二分查找:读入文件,排序,二分查找key,统计时间;// (3)分块查找:读入文件,分100块,每块300+数字,查找key,统计时间// (4)二分查找树:读入文件,形成BST,查找key,统计时间//二叉排序树:建立,查找#include "stdio.h"#include "time.h"#include "stdlib.h"struct JD{//定义分块查找的链表结点结构int data;JD *next;};struct INDEX_T{//定义分块查找中,索引表结构int max;//这一块中最大的数字,<maxJD *block;//每一块都是一个单向链表,这是指向块的头指针};INDEX_T myBlock[100];//这是索引表的100项struct NODE{//定义的二分查找树结点结构int data;NODE *left;NODE *right;};const int COUNT=50000;//结点个数int key=666;//待查找的关键字int m=1;//int *array2;void createData(char strFileName[]){//产生随机整数,存入文件srand((unsigned int)time(0));FILE *fp=fopen(strFileName,"w");for(int i=1;i<=COUNT;i++)fprintf(fp,"%d,",rand());fclose(fp);}void createBST(NODE* &bst){//产生5万个随机整数,创建二叉排序树FILE *fp=fopen("data.txt","r");for(int i=1;i<=COUNT;i++){int num;fscanf(fp,"%d,",&num);//从文件中读取一个随机整数//若bst是空子树,第一个结点就是根结点//若bst不是空子树,从根结点开始左小右大,查找这个数字,找到了直接返回,//找不到,就插入到正确位置//创建一个结点NODE* p=new NODE;p->data=num;p->left=0;p->right=0;if(0==bst)//空子树{bst=p;continue;}//非空子树,//在bst中,查找给结点,NODE *q=bst;//总是从根结点开始查找while(1){if(p->data == q->data)//找到了,直接退出break;if(p->data < q->data && q->left==0){//小,往左找,且左边为空,直接挂在q之左q->left=p;break;}if(p->data < q->data && q->left!=0){//小,往左找,且左边非空,继续往左边找q=q->left;continue;}if(p->data > q->data && q->right==0){//大,往右找,且右边为空,直接挂在q之右q->right=p;break;}if(p->data > q->data && q->right!=0){//大,往右找,且右边非空,继续往右边找q=q->right;continue;}}}}int BST_Search(NODE *bst,int key){//在bst中找key,if(0==bst)return -1;//非空子树,//在bst中,查找给结点,NODE *q=bst;//总是从根结点开始查找while(1){if(key == q->data)//找到了,直接退出return 1;if(key < q->data && q->left==0)//小,往左找,且左边为空,找不到return -1;if(key < q->data && q->left!=0)//小,往左找,且左边非空,继续往左边找{q=q->left;continue;}if(key > q->data && q->right==0)//大,往右找,且右边为空,找不到return -1;if(key > q->data && q->right!=0){//大,往右找,且右边非空,继续往右边找q=q->right;continue;}}}void inOrder(NODE *bst){if(bst!=0){inOrder(bst->left);array2[m]=bst->data;//反写回array数组,使数组有序// printf("%7d",array2[m]);m++;inOrder(bst->right);}}int getBSTHeight(NODE *bst){if(bst==0)return 0;else{int hl=getBSTHeight(bst->left);int hr=getBSTHeight(bst->right);int h=hl>hr?hl:hr;return h+1;}}void makeArray(int array[],char strFileName[]) {//生成5万个随机整数FILE *fp=fopen(strFileName,"r");int i=1;while(!feof(fp)){fscanf(fp,"%d,",&array[i]);// printf("%6d",array[i]);i++;}}int Seq_Search(int array[],int key){//在无序顺序数组中,找data是否存在,-1=不存在,存在返回位置下标//监视哨:把要找的那个数放到首部array[0]=key;//for(int i=COUNT;array[i]!=key;i--);if(i>0)//找到了,返回下标return i;return -1;//查找不成功,返回-1}int Bin_Search(int array[],int key){//在有序存储的数组中查找key,找到返回位置,找不到返回-1 int low=1,high=COUNT,mid;while(1){if(low>high)//找不到return -1;mid=(low+high)/2;if(key == array[mid])return mid;else if(key<array[mid])high=mid-1;elselow=mid+1;}}void makeBlock(INDEX_T myBlock[],char strFileName[]) {//从文件中读取整数,分配到块中去//1.初始化块索引表,分100块,400,800,1200,for(int i=0;i<=99;i++){myBlock[i].max=400+400*i;//400,800,1200, (40000)myBlock[i].block=0;}//2.打开文件,读取整数,把每一个整数分配到相应的块中去FILE *fp=fopen(strFileName,"r");while(!feof(fp)){int num=0;fscanf(fp,"%d,",&num);//把num分配到num/400块中,挂到该块链表第一个int blockID=num/400;//求出应该挂在的块号//生成一个新节点,把num放进去,挂上JD *p=new JD;p->data=num;p->next=myBlock[blockID].block;myBlock[blockID].block=p;}fclose(fp);}int Block_Search(INDEX_T myBlock[],int key){int blockID=key/400;//找到块号JD* p=myBlock[blockID].block;while(p!=0){if(p->data==key)return blockID;//能找到p=p->next;}return -1;//找不到}void main(){clock_t begin,end;int pos=-1;//1.生成文件,存入5万个随机整数createData("data.txt");//2.顺序查找int *array=new int[COUNT+1];makeArray(array,"data.txt");//从文件中读取数据begin=clock();for(int k=1;k<=10000;k++)pos=Seq_Search(array,key);end=clock();printf("顺序查找:%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//3.二分查找树NODE *bst=0;createBST(bst);//产生5万个随机数字,建立一个二叉排序树begin=clock();for(k=1;k<=10000;k++)pos=BST_Search(bst,key);//在bst中找key,找到返回1,找不到返回-1end=clock();printf("二叉排序树查找:%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);array2=new int[COUNT+1];inOrder(bst);//中序输出bst// int height=getBSTHeight(bst);//求出bst的高度// printf("BST高度=%d.\n\n",height);//4.二分查找,利用前面二叉排序树产生的array2,查找key begin=clock();for(k=1;k<=10000;k++)pos=Bin_Search(array2,key);end=clock();printf("二分查找:%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//5.分块查找,关键字范围[0,32767],分配到100块中去,每一块中存400个数字makeBlock(myBlock,"data.txt");//从文件中读取数据,产生块begin=clock();for(k=1;k<=10000;k++)pos=Block_Search(myBlock,key);//在block中查找key,找到返回块号,找不到返回-1end=clock();printf("分块查找:%d所在的块=%d.时间=%d毫秒\n",key,pos,end-begin);/*for(k=0;k<=99;k++){printf("\n\n\n第%d块<%d:\n",k,myBlock[k].max);JD *q=myBlock[k].block;//让q指向第k块的第一个结点while(q!=0){//输出第k块中所有数字printf("%7d ",q->data);q=q->next;}}*/}。
数据结构查找算法实验报告
数据结构查找算法实验报告数据结构查找算法实验报告---------------------------------1.引言在计算机科学中,查找算法是一种用于在数据集合中寻找特定元素的算法。
查找算法在各种应用中广泛使用,例如数据库检索,关键字搜索等。
本次实验旨在研究和探索不同的数据结构查找算法,如线性查找、二分查找、哈希查找等,并比较它们的性能和适用场景。
2.线性查找2.1 算法原理线性查找又称为顺序查找,它从数据集合的起始位置开始,逐个比较元素直到找到目标元素或遍历完整个集合。
线性查找是最简单的查找算法,但效率较低,时间复杂度为O(n)2.2 算法步骤●从数组的第一个元素开始遍历,依次比较元素与目标元素是否相等。
●如果相等,返回目标元素的索引值。
●如果遍历完整个数组仍未找到目标元素,返回未找到的标志。
2.3 算法实现```function linearSearch(arr, target) {for (let i = 0。
i < arr.length。
i++) {if (arri === target) {return i。
}}return -1。
}```3.二分查找3.1 算法原理二分查找是一种高效的查找算法,要求数据集合必须有序。
它通过重复将数据集合一分为二,直到找到目标元素或确定目标元素不存在。
二分查找的时间复杂度为O(log n)3.2 算法步骤●将数据集合的起始位置和结束位置分别设为low和high。
●计算中间位置mid,并将mid元素与目标元素进行比较。
●如果mid元素等于目标元素,则返回mid。
●如果mid元素大于目标元素,则将high设为mid-1。
●如果mid元素小于目标元素,则将low设为mid+1。
●重复以上步骤,直到low大于high或找到目标元素。
3.3 算法实现```function binarySearch(arr, target) {let low = 0。
数据结构中查找和排序算法实验报告
mergesort(ListType &r,ListType &r1,int s,int t)
{
if (s==t)
r1[s]=r[s];
else
{
mergesort(r,r2,s,s+t/2);
mergesort(r,r2,s+t/2+1,t);
merge(r2,s,s+t/2,t,r1);
}
}
4.堆排序算法描述如下:
堆排序要解决两个问题:1、如何由一个无序序列建成一个堆?2、如何在输出堆顶元素之后,调整剩余元素成为一个新的堆?
问题2的解决方法:
四.实验数据与清单:
1.折半查找算法描述如下:
int Search_Bin(SSTable ST,KeyType key)
low=1;high=ST.length;
while(low<=high){
sift(ListType &r,int k,int m)
{
i=k;j=2*i;x=r[k].key;finished=FALSE;
t=r[k];
while((j<=m)&&(!finished))
{
if ((j<m)&&(r[j].key>r[j+1].key)) j++;
if (x<=r[j].key)
通过本次实验,我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候,需要我把理论变为上机调试,这无疑是最难的部分,有时候我想不到合适的算法去解决问题,就请教同学,上网搜索,逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高,以前我很不懂这门课,觉得它很难,但是现在明白了一些代码的应用,明白了每个程序都有相似的特点,通用的结构,也学会了静下心来写程序。我以后还要把没学好的知识点补齐,克服编程过程中的难关,打实基础,向更深入的层次发展。
国家开放大学《数据结构》课程实验报告(实验6——查找)参考答案
/*按平均成绩进行折半查找并插入新记录,使表仍按平均成绩降序排列*/
int BinSort(Student *a,int n,Student x)
{
int low,high,mid;
int i,j;
/*折半查找*/
low=0;
high=n-1;
while(low<=high)
{
mid=(low+high)/2;
void main()
{
Student a[N]={{"Zhao",95},{"Qian",90},{"Sun",86},{"Li",75}},x;
int n=4; /*学生人数,即表长*/
printf("初始%d位学生的信息表如下:\n",n);
Display(a,n);
printf("\n\n");
《数据结构》课程实验报告
(实验6——查找)
学生姓名
学 号
班 级
指导老师
实验名称
实验成绩
实验报告
实
验
概
述
实验目的:
某班学生成绩信息表中,每个学生的记录已按平均成绩由高到低排好序,后来发现某个学生的成绩没有登记到信息表中,使用折半查找法把该同学的记录插入到信息表中,使信息表中的记录仍按平均成绩有序。
实验要求:
(1)建立现有学生信息表,平均成绩已有序。
(2)输入插入学生的记录信息。
(3)用折半查找找到插入位置,并插入记录。
设计思路:
(1)用结构数组存储成绩信息表。
(2)对记录中的平均成绩进行折半查找并插入。
实验内容源自程序代码:/*实验5.1折半查找*/
数据结构实验报告-查找
6 查找1. 实验题目与环境1.1实验题目及要求(1)折半查找编程实现折半查找的非递归算法。
(2)二叉排序树编程实现一棵二叉排序树,包括插入、删除、查找等功能。
(3)散列表的应用选择合适的散列函数和冲突处理方法,编程实现QQ账户的申请与登录。
2. 问题分析(1)折半查找二分查找,基本思想为:首先将待查的key值与有序数据表中的中间位置mid上的元素进行比较,若相等则查找完成;否则,若R[mid] > key,说明待查元素可能在左子表中,则在左子表中继续进行二分查找,若R[mid] < key,说明待查元素可能在右子表中,则在右子表中继续进行二分查找。
如此进行下去,直到找到关键字为key的元素,或者未找到,则查找失败。
(2)二叉排序树二叉排序树的建立,反复调用插入算法,就可以构造出一棵二叉排序树。
二叉排序树的插入算法,如果二叉排序树为空,新建结点*s,数值域赋值,左右孩子置空;当二叉排序树非空时,将待插入的s的数据域data与树根结点关键字BT->data比较,若BT->data <= data,则将s所指的结点数值域data插入到右子树中,否则插入到左子树中。
二叉排序树创建成功后,中序遍历输出结果,查看是否为有序序列,是则成功,否则失败。
(3)散列表的应用输入首先给出一个正整数N(≤10^5 ),随后给出N行指令。
每行指令的格式为:“命令符(空格)QQ号码(空格)密码”。
其中命令符为“N”(代表New)时表示要新申请一个QQ号,后面是新帐户的号码和密码;命令符为“L”(代表Login)时表示是老帐户登陆,后面是登陆信息。
QQ号码为一个不超过10位、但大于1000(据说QQ老总的号码是1001)的整数。
密码为不小于6位、不超过16位、且不包含空格的字符串。
3. 测试用例(1)折半查找数据:数组1 2 3 4 5 6 7 8 9 10(2)二叉排序树数据:建立二叉树5 1 9 6 3 2 8 7 4 0(3)散列表的应用输入样例:5L 1234567890 myQQ@N 1234567890 myQQ@N 1234567890 myQQ@L 1234567890 myQQ@qqL 1234567890 myQQ@4. 结果展示(1)折半查找图1-1建立数据表(a)查找成功(b)查找失败图1-2查找结果展示(2)二叉排序树(a)无重复数据(b)有重复数据图2二叉排序树建立与中序遍历结果(3)散列表的应用5.实验总结本次实验中学会了折半查找和二叉排序树还有散列表的各个功能和操作,通过实验对栈队列得到了更加深刻的认识和更完善的运用。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验四——查找
一、实验目的
1.掌握顺序表的查找方法,尤其是折半查找方法;
2.掌握二叉排序树的查找算法。
二、实验内容
1.建立一个顺序表,用顺序查找的方法对其实施查找;
2.建立一个有序表,用折半查找的方法对其实施查找;
3.建立一个二叉排序树,根据给定值对其实施查找;
4.对同一组数据,试用三种方法查找某一相同数据,并尝试进行性能分析。
三、实验预习内容
实验一包括的函数有:typedef struct ,创建函数void create(seqlist & L),输出函数void print(seqlist L),顺序查找int find(seqlist L,int number),折半查找int halffind(seqlist L,int number)
主函数main().
实验二包括的函数有:结构体typedef struct,插入函数void insert(bnode * & T,bnode * S),void insert1(bnode * & T),创建函数void create(bnode * & T),查找函数bnode * search(bnode * T,int number),主函数main().
四、上机实验
实验一:
1.实验源程序。
#include<>
#define N 80
typedef struct
{
int number; umber;
for(i=1;[i].number!=0;)
{
cin>>[i].name>>[i].sex>>[i].age;
++;
cout<<endl;
cin>>[++i].number;
}
}
umber<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;
}
umber==number)
return i;
}
umber)
return mid;
else
if(number<[mid].number)
high=mid-1;
else
low=mid+1;
}
return 0;
}
void main()
{
int i,number;
seqlist L;
create(L);
print(L);
cout<<"折半查找:"<<endl;
cout<<"输入学生学号:";
cin>>number;
if((i=halffind(L,number))!=0)
cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;
else
cout<<"失败!"<<endl;
cout<<"顺序查找:"<<endl;
cout<<"输入学生学号:";
cin>>number;
if((i=find(L,number))!=0)
cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;
else
cout<<"失败!"<<endl;
}
实验二:
#include<>
typedef struct
{
int number; 立二叉排序树"<<"\n\t2.插入学生信息"<<"\n\t3.查找学生信息"<<endl;
cout<<"选择:";
cin>>choice;
switch(choice)
{
case 1:{create(T);cout<<"成功建立!"<<endl;};break;
case 2:{insert1(T);cout<<"插入成功!"<<endl;};break;
case 3:{cout<<"输入待查学生的学号:";cin>>number;p=search(T,number);
if(p)
cout<<p-><<"\t"<<p-><<"\t"<<p-><<"\t"<<p-><<endl;
else
cout<<"查找失败!"<<endl;};break;
}
cout<<"Continue(Y/N):";
cin>>ctinue;
if(ctinue=='y'||ctinue=='y')
flag=1;
else
flag=0;
}
}
2.实验结果(截图)。
实验一:
开始界面:
插入数据界面:
查找信息的界面;
实验二:
开始界面:
建立二叉树:
插入学生的信息:
查找学生信息:
再次插入学生信息:
五、实验总结(实验过程中出现的问题、解决方法、结果或其它)
在实验一中:创建的学生信息包含四个方面:学号,姓名,性别,年龄。
要分别定义四个数组来保存它们。
其中要将学生的学号定义为查找的关键字。
顺序查找按学号就可以,在折半查找中,我们需要定义high和low来保存每次比较完之后的数组的下标。
在实验二中:二叉排序树中的创建树,输出一个要插入的学生信息,学号为主要关键字进行插入,首先进行比较在决定是插在左子树还是右子树。
主要问题是如何一次保存学生的四个信息这就要求在输入学生信息时候,要定义学号为关键字输入。
在输入学生信息时候仍要调用插入函数对学生信息进行保存。