实验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. 哈希查找法在数据量较大时，查找效率最高，但需要考虑哈希冲突的问题。
六、实验心得通过本次实验，我们对数据查找方法有了更深入的了解，掌握了顺序查找法、二分查找法和哈希查找法的基本原理和实现方法。
《数据结构》实验报告三：几种查找算法的实现和比较
第三次实验报告：几种查找算法的实现和比较//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. 分析不同查找算法的效率，了解其适用场景。
3. 通过实验验证算法的正确性和性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 数据集：随机生成的10000个整数，范围在1到100000之间。
三、实验内容本次实验主要对以下几种查找算法进行研究和实现：1. 顺序查找2. 二分查找3. 哈希查找四、实验步骤1. 顺序查找（1）定义一个列表，包含10000个随机生成的整数。
（2）编写顺序查找函数，实现查找功能。
（3）对列表进行顺序查找，记录查找过程和结果。
2. 二分查找（1）定义一个有序列表，包含10000个随机生成的整数。
（2）编写二分查找函数，实现查找功能。
（3）对有序列表进行二分查找，记录查找过程和结果。
3. 哈希查找（1）定义一个哈希表，包含10000个随机生成的整数。
（2）编写哈希查找函数，实现查找功能。
（3）对哈希表进行哈希查找，记录查找过程和结果。
五、实验结果与分析1. 顺序查找（1）查找过程：从列表的第一个元素开始，逐个比较，直到找到目标值或遍历完整个列表。
（2）查找结果：查找成功时，返回目标值在列表中的索引；查找失败时，返回-1。
（3）性能分析：顺序查找的时间复杂度为O(n)，在数据量较大时效率较低。
2. 二分查找（1）查找过程：首先确定查找范围的起始和结束索引，然后根据中间值与目标值的大小关系，不断缩小查找范围，直到找到目标值或查找范围为空。
（2）查找结果：查找成功时，返回目标值在列表中的索引；查找失败时，返回-1。
（3）性能分析：二分查找的时间复杂度为O(logn)，在数据量较大时效率较高。
3. 哈希查找（1）查找过程：根据目标值计算哈希表中的索引，直接访问对应位置的数据。
（2）查找结果：查找成功时，返回目标值在哈希表中的索引；查找失败时，返回-1。
（3）性能分析：哈希查找的时间复杂度为O(1)，在数据量较大时效率最高。
查找排序实验报告总结
一、实验目的本次实验旨在通过编写程序实现查找和排序算法，掌握基本的查找和排序方法，了解不同算法的优缺点，提高编程能力和数据处理能力。
二、实验内容1. 查找算法本次实验涉及以下查找算法：顺序查找、二分查找、插值查找。
（1）顺序查找顺序查找算法的基本思想是从线性表的第一个元素开始，依次将线性表中的元素与要查找的元素进行比较，若找到相等的元素，则查找成功；若线性表中所有的元素都与要查找的元素进行了比较但都不相等，则查找失败。
（2）二分查找二分查找算法的基本思想是将待查找的元素与线性表中间位置的元素进行比较，若中间位置的元素正好是要查找的元素，则查找成功；若要查找的元素比中间位置的元素小，则在线性表的前半部分继续查找；若要查找的元素比中间位置的元素大，则在线性表的后半部分继续查找。
重复以上步骤，直到找到要查找的元素或查找失败。
（3）插值查找插值查找算法的基本思想是根据要查找的元素与线性表中元素的大小关系，估算出要查找的元素应该在大致的位置，然后从这个位置开始进行查找。
2. 排序算法本次实验涉及以下排序算法：冒泡排序、选择排序、插入排序、快速排序。
（1）冒泡排序冒泡排序算法的基本思想是通过比较相邻的元素，将较大的元素交换到后面，较小的元素交换到前面，直到整个线性表有序。
（2）选择排序选择排序算法的基本思想是在未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
（3）插入排序插入排序算法的基本思想是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
（4）快速排序快速排序算法的基本思想是选择一个元素作为基准元素，将线性表分为两个子表，一个子表中所有元素均小于基准元素，另一个子表中所有元素均大于基准元素，然后递归地对两个子表进行快速排序。
三、实验结果与分析1. 查找算法通过实验，我们发现：（1）顺序查找算法的时间复杂度为O(n)，适用于数据量较小的线性表。
编程逻辑算法实验报告
编程逻辑算法实验报告1. 实验目的本实验旨在通过实际的编程任务，提升学生的编程逻辑算法能力，培养学生解决实际问题的能力。
2. 实验内容本实验要求学生完成以下编程任务：1. 实现一个简单的计算器程序，能够进行加减乘除运算；2. 实现一个排序算法，能够对给定的一组数据进行升序排序；3. 实现一个查找算法，能够在给定的一组数据中查找指定的元素。
3. 实验过程3.1 计算器程序在实现计算器程序时，我们首先定义了四个函数，分别用于进行加、减、乘、除运算。
然后，我们通过用户输入选择运算操作符和操作数，并根据选择调用相应的函数进行运算。
最后，将结果输出给用户。
pythondef add(a, b):return a + bdef subtract(a, b):return a - bdef multiply(a, b):return a * bdef divide(a, b):if b == 0:return "Error: can't divide by zero!"else:return a / boperator = input("Please enter the operator (+, -, *, /): ")operand1 = float(input("Please enter the first operand: "))operand2 = float(input("Please enter the second operand: "))if operator == '+':result = add(operand1, operand2)elif operator == '-':result = subtract(operand1, operand2)elif operator == '*':result = multiply(operand1, operand2)elif operator == '/':result = divide(operand1, operand2)else:result = "Error: invalid operator!"print("Result:", result)3.2 排序算法在实现排序算法时，我们选择了冒泡排序算法。
软件技术基础实验指导书(1)
软件技术基础实验指导书2014年9月1日目录实验一斐波那契数列的实现算法及分析 (3)实验二顺序表的实现与应用 (5)实验三链表的实现和应用 (7)实验四栈的实现和应用 (9)实验五队列 (11)实验六二叉树的创建和遍历 (12)实验七图 (15)实验八哈夫曼树及哈夫曼编码 (16)实验九查找算法的实现 (19)实验十内部排序算法的实现 (26)实验十一迷宫问题 (29)实验十二 B+树程序设计 (30)实验十三四叉树程序设计 (31)实验十四修路方案问题 (32)实验一斐波那契数列的实现算法及分析实验目的：1.掌握分别用递归和非递归方法计算斐波那契（Fibonacci）数列。
2.掌握算法性能测试的方法，并能进行算法分析和比较。
实验环境（硬/软件要求）：Windows 2000, VisualC++ 6.0实验内容：二阶Fibonacci数列的定义如下：F0=1，F1=1, F2=2,F3=3,F4=5,。
，Fi=F（i-1）=F(i-2) （i>=1）.试用递归法和非递归法两种方法写出计算Fn的函数。
实验要求：1.完成计算Fn的递归函数Fib-rec.2.完成计算Fn的非递归数列Fib-ite.3.当n=10,15,20,25,30,35,40,45时测试以上两种算法执行的时间，并把测试结果填写在附表1-1中。
附表1-1 测试表注：表格中填写的是测试时间，单位μm.4.试解释两种算法在执行时间上的不同，并对两种算法进行算法分析。
【C语言源程序】#include <stdio.h>#include <time.h>Long Fib-rec(int n){if（n==0||n==1）return(1)；else return(Fib-rec(n-1) + Fib-rec(n-2) )；}long Fib-ite(int n){long fib1,fib2,fib；int i；fib1=1；fib2=1；for (i=3；i<=n,i + + ){fib=fib1+fib2；fib1=fib2；fib2=fib；}return fib；}void main ( ){clock-t us1, us2；int n；printf(“请输入n：\n”)；scanf(“%d,&n)；us1=clock( )；printf(“递归函数计算结果：%1d\n”,Fib-rec(n) )； us2=clock( )；printf(“递归函数执行时间%1d毫秒\n”，us2-us1)；us1=clock( )；printf(“非递归函数计算结果：%1d\n”,Fib-ite(n) )； us2=clock( )；printf(非递归函数执行时间%1d毫秒\n”，us2-us1)；}实验二顺序表的实现与应用实验目的：1.掌握线性表的概念。
《数据结构》教学大纲
《数据结构》教学大纲一、课程基本信息二、课程描述（一）课程简介《数据结构》是信息类各专业的核心基础课程，是一门理论与实践相结合的课程，在整个信息相关专业的教学体系中处于举足轻重的地位。
数据结构是设计和实现编译程序、操作系统、数据库系统及其它系统程序和大型应用程序的重要基础。
通过本课程理论和实践的教学，使学生较牢固地掌握数据结构的基本概念、原理、算法，了解算法复杂性的度量方法，初步掌握根据所求解问题的性质选择合理的数据结构，并对时间空间复杂性进行必要的控制，培养和提高学生理论、抽象、设计的能力，掌握数据结构和算法的设计分析技术，提高程序设计的质量，为将来的研究和开发工作打下坚实的基础。
“Data Structures and Algorithms”, one of the most important core courses in Computer Science. The course also covers fundamental data structures and classical algorithms which are widely used in the succeeding specialized courses,such as Operating Systems, Software Engineering, Database Systems, Compiler Principles, Computer Graphics and Human Computer Interaction.What is the combination of data structures and algorithms? Niklaus Wirth wrote a book titled "Algorithms + Data Structures = Programs", which points out their important roles in computing discipline:algorithm and data structure are two closely linked and indivisible parts of programming.The course will follow the idea of“Algorithms + Data Structures = Programs”, aimed at improving students’ knowledge and skills of theory, abstraction and design in problem solving.This course will focus on data structures and algorithms for manipulating them. Data structures for storing information in tables, lists, trees, queues and stacks will be covered. Some basic graph and discrete transform algorithms will also be discussed. On a solid basis of the fundamental theory, the students will analyze the problems using problem, data and algorithm abstraction. Making a tradeoff between space and time complexity, the students will learn how to organize data reasonably, design efficient and effective algorithms, and implement high quality programs, so that they can solve real-world complex problems.After studying the course, the students’ ability of abstract thinking and problem solving should have improvedconsiderably.Their programming skills and the quality of their codes would have increased as well. After studying this course, students should be well prepared for further study, engineering and research in computer related areas.（二）课程教学基本设计本课程由大班授课、小班讨论和实验组成，学时分配分别为48学时、16学时、16学时。
《数据结构》教学大纲
《数据结构》教学大纲Data Structure课程编号：J6110G0003课程性质：学科基础课程适用专业：计算机科学与技术、网络工程、数字媒体技术先行课：计算机科学导论、离散数学、高级语言程序设计；后续课：无。
学分数：5主讲教师：任燕、王命延、冯豫华、周石林、王玮立等一、课程的目的与任务数据结构是信息与计算科学专业中一门重要的专业基础课程。
当用计算机来解决实际问题时，就要涉及到数据的表示及数据的处理，而数据表示及数据处理正是数据结构课程的主要研究对象，通过这两方面内容的学习，为后续软件方面的课程打下了厚实的知识基础，同时也提供了必要的技能训练。
因此，数据结构课程在计算机应用专业中具有举足轻重的作用。
本课程的目的是使学生掌握数据组织、存储和处理的常用方法，为以后进行软件开发和学习后续专业课程打下基础。
主要任务是讨论现实世界中数据的各种逻辑结构，在计算机中的存储结构以及进行各种非数值运算的算法。
本课程达到《认证通用标准》规定中关于“毕业要求”的第三款项（具有运用工程基础知识和本专业基本理论知识解决问题的能力，具有系统的工程实践学习经历；了解本专业的前沿发展现状和趋势）、第四款项（具备设计和实施工程实验的能力，并能够对实验结果进行分析）。
二、课程的基本要求通过本课程的学习，要求学生了解数据结构及其分类、数据结构与算法的密切关系；熟悉各种基本数据结构及其操作，学会根据实际问题要求来选择数据结构；掌握设计算法的步骤和算法分析方法；掌握数据结构在排序、查找和路由选择等常用算法中的应用。
最后学生应达到知识技能两方面的目标：在基础方面，要求学生掌握常用数据结构的基本概念及其不同的实现方法；在技能方面，通过系统学习能够在不同存储结构上实现不同的运算，并对算法设计的方式和技巧有所体会。
三、课程教学内容第一章绪论基本要求:掌握数据结构的基本概念，抽象数据类型在软件设计中的意义，算法的概念和算法的时间复杂度分析，了解算法的描述和评价。
顺序查找实验报告
一、实验目的1. 理解顺序查找算法的基本原理和实现方法；2. 掌握顺序查找算法的性能分析；3. 通过实际编程，验证顺序查找算法的正确性和效率。
二、实验原理顺序查找算法是一种基本的查找算法，它的工作原理是从线性表的第一个元素开始，逐个比较元素，直到找到满足条件的元素或者查找结束。
顺序查找算法的时间复杂度为O(n)，空间复杂度为O(1)。
三、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发环境：PyCharm四、实验步骤1. 创建一个线性表，包含20个随机整数；2. 编写顺序查找算法，实现查找功能；3. 测试顺序查找算法，验证其正确性和效率；4. 分析实验结果，总结实验心得。
五、实验代码```pythonimport random# 创建一个包含20个随机整数的线性表data = [random.randint(1, 100) for _ in range(20)]# 定义顺序查找算法def sequential_search(data, target):for i in range(len(data)):if data[i] == target:return ireturn -1# 测试顺序查找算法target = random.randint(1, 100)index = sequential_search(data, target)if index != -1:print(f"找到目标元素：{target}，位置：{index}")else:print(f"未找到目标元素：{target}")```六、实验结果与分析1. 实验结果：在随机生成的20个整数线性表中，我们找到了目标元素，位置为第8个。
2. 实验分析：（1）正确性分析：通过测试，我们验证了顺序查找算法的正确性。
在给定的线性表中，我们找到了目标元素，并输出了其位置。
查找实验报告
查找实验报告第一篇：查找实验报告实验六查找实验目的：掌握几种查找的思想及算法问题分析：（一）顺序查找 1.查找思想从表的一端开始逐个将记录的关键字和给定K值进行比较，若某个记录的关键字和给定K值相等，查找成功；否则，若扫描完整个表，仍然没有找到相应的记录，则查找失败。
2.算法实现int Seq_Search(SST able ST,int key){int p;} ST.data[0].key=key;/* 设置监视哨兵,失败返回0 */ for(p=ST.length;ST.data[p].key!=key;p--);return(p);3.算法分析设查找每个记录成功的概率相等，即Pi=1/n；查找第i个元素成功的比较次数Ci=n-i+1 ；◆ 查找成功时的平均查找长度ASL：◆包含查找不成功时：查找失败的比较次数为n+1，若成功与不成功的概率相等，对每个记录的查找概率为Pi=1/(2n)，则平均查找长度ASL：（二）折半查找前提条件：查找表中的所有记录是按关键字有序(升序或降序)。
查找过程中，先确定待查找记录在表中的范围，然后逐步缩小范围(每次将待查记录所在区间缩小一半)，直到找到或找不到记录为止。
1.查找思想用Low、High和Mid表示待查找区间的下界、上界和中间位置指针，初值为Low=1，High=n。
⑴取中间位置Mid：Mid=⎣(Low+High)/2⎦；⑵比较中间位置记录的关键字与给定的K值：①相等：查找成功；②大于：待查记录在区间的前半段，修改上界指针：High=Mid-1，转⑴ ；③小于：待查记录在区间的后半段，修改下界指针：Low=Mid+1，转⑴ ；直到越界(Low>High)，查找失败。
2.算法实现int Bin_Search(SST able ST , KeyType k){int low=1，high=ST.length, mid;while(low<=high){mid=(low+high)/2;if(EQ(ST.data[mid].key, k))return(mid);else if(LT(ST.dat[mid].key, k))low=mid+1;else high=mid-1;}return(0);/*查找失败*/ } 3.算法分析①查找时每经过一次比较，查找范围就缩小一半，该过程可用一棵二叉树表示：◆根结点就是第一次进行比较的中间位置的记录；◆ 排在中间位置前面的作为左子树的结点；◆ 排在中间位置后面的作为右子树的结点；对各子树来说都是相同的。
算法与数据结构实验册(2)
（理工类）课程名称：算法与数据结构专业班级： 15软件二班学生学号： 151 学生姓名：孙毅安所属院部：软件工程学院指导教师：黄丹丹2016 ——2017 学年第 1 学期金陵科技学院教务处制实验报告书写要求实验报告原则上要求学生手写，要求书写工整。
若因课程特点需打印的，要遵照以下字体、字号、间距等的具体要求。
纸张一律采用A4的纸张。
实验报告书写说明实验报告中一至四项内容为必填项，包括实验目的和要求；实验仪器和设备；实验内容与过程；实验结果与分析。
各院部可根据学科特点和实验具体要求增加项目。
填写注意事项（1）细致观察，及时、准确、如实记录。
（2）准确说明，层次清晰。
（3）尽量采用专用术语来说明事物。
（4）外文、符号、公式要准确，应使用统一规定的名词和符号。
（5）应独立完成实验报告的书写，严禁抄袭、复印，一经发现，以零分论处。
实验报告批改说明实验报告的批改要及时、认真、仔细，一律用红色笔批改。
实验报告的批改成绩采用百分制，具体评分标准由各院部自行制定。
实验报告装订要求实验批改完毕后，任课老师将每门课程的每个实验项目的实验报告以自然班为单位、按学号升序排列，装订成册，并附上一份该门课程的实验大纲。
实验项目名称：顺序表实验学时： 2 同组学生姓名：陶渊，李学波，王天伟，孙兵，王磊，贲小康，梁华龙，倪云鹏实验地点：实验日期： 10.13 实验成绩：批改教师：批改时间：实验1 顺序表一、实验目的和要求掌握顺序表的定位、插入、删除等操作。
二、实验仪器和设备Turbo C 2.0三、实验内容与过程（含程序清单及流程图）1、必做题（1）编写程序建立一个顺序表，并逐个输出顺序表中所有数据元素的值。
编写主函数测试结果。
（2）编写顺序表定位操作子函数，在顺序表中查找是否存在数据元素x。
如果存在，返回顺序表中和x值相等的第1个数据元素的序号（序号从0开始编号）；如果不存在，返回－1。
编写主函数测试结果。
（3）在递增有序的顺序表中插入一个新结点x，保持顺序表的有序性。
数据结构实验任务书(8个)
目录实验1 线性表顺序存储的应用 (2)实验2 线性表链式存储的应用 (5)实验3 栈及其应用 (6)实验4 队列及其应用 (7)实验5 树及其应用 (8)实验6 图的遍历和连通性应用 (9)实验7 图的最短路径应用 (11)实验8 查找和排序应用 (12)实验1 线性表顺序存储的应用实验目的1．熟悉C语言的上机环境，掌握C语言的基本结构。
2．会定义线性表的顺序存储结构。
3．熟悉对顺序表的一些基本操作和具体的函数定义。
4．掌握在线性表的顺序存储结构上的一些其它操作。
实验要求1．独立完成；2．程序调试正确，有执行结果。
实验内容1、基础题：编写应用程序（填空），实现可以在顺序表中插入任意给定数据类型（定义为抽象数据类型）数据的功能。
要求在主函数中定义顺序表并对该顺序表插入若干个整数类型的数据（正整数），对它们求和并输出。
请使用动态内存分配的方式申请数组空间，并把主函数设计为一个文件SeqList.cpp，其余函数设计为另一个文件SeqList.h。
请填空完成以下给出的源代码并调试通过。
（1）文件SeqList.h:typedef struct List{ElemType *elem;int length;int listsize;}SeqList;void InitList(SeqList &L){ //初始化线性表…………}void ClearList(SeqList &L){ //清除线性表………………}int LengthList(SeqList L){ //求线性表长度………..}bool InsertList(SeqList &L, ElemType item, int pos){ //按给定条件pos向线性表插入一个元素…….}ElemType GetList(SeqList L, int pos){ //在线性表L中求序号为pos的元素，该元素作为函数值返回…………..}（2）文件SeqList.cpp：#include <stdio.h>#include <stdlib.h>typedef ElemType;#define MAXSize 10#include "SeqList.h"void main(void){SeqList myList;int i=1, x, sum=0, n;InitList ( );scanf(“%d”, &x);while ( x!= -1 ){if ( InsertList (myList, , i )==0) {printf("错误!\n");return ;}i++;scanf(“%d”, &x);}n = LengthList (myList);for (i=1; i<=n; i++){x=GetList(myList, i);sum = + x;}printf("%d\n ", sum);ClearList(myList);}2、提高部分：编写函数bool DeleteElem(SeqList &L, int min, int max)实现从顺序表中删除其值在给定值min和max之间（min < max）的所有元素，要求把该函数添加到文件SeqList.h中，并在主函数文件SeqList.cpp中添加相应语句进行测试。
实验8-9查找和排序
实验八、九：查找、排序算法的应用班级学号姓名成绩一、实验目的1 掌握查找的不同方法，并能用高级语言实现查找算法。
2 熟练掌握顺序表和有序表的顺序查找和二分查找方法。
3 掌握排序的不同方法，并能用高级语言实现排序算法。
4 熟练掌握顺序表的选择排序、冒泡排序和直接插入排序算法的实现。
二、实验内容1 创建给定的顺序表。
表中共包含八条学生信息，信息如下：学号姓名班级 C 数据结构1 王立03511 85 762 张秋03511 78 883 刘丽03511 90 794 王通03511 75 865 赵阳03511 60 716 李艳03511 58 687 钱娜03511 95 898 孙胜03511 45 602 使用顺序查找方法，从查找表中查找姓名为赵阳和王夏的学生。
如果查找成功，则显示该生的相关信息；如果查找不成功，则给出相应的提示信息。
3 使用二分查找方法，从查找表中查找学号为7和12的学生。
如果查找成功，则显示该生的相关信息；如果查找不成功，则给出相应的提示信息。
（注意：创建静态查找表时必须按学号的从小到大排列！）4 使用直接插入排序方法，对学生信息中的姓名进行排序。
输出排序前和排序后的学生信息表，验证排序结果。
5 使用直接选择排序方法，对学生信息中的C成绩进行排序。
输出排序前和排序后的学生信息表，验证排序结果。
6 使用冒泡排序方法，对学生信息中的数据结构成绩进行排序。
输出排序前和排序后的学生信息表，验证排序结果。
7 编写一个主函数，将上面函数连在一起，构成一个完整程序。
8 将实验源程序调试并运行。
三、实验结果#include<stdio.h> #include<stdlib.h> #include<string.h> int Number; struct Node{char * Name;char * Class;int Number;int Grade_C;int Grade_DS;struct Node * Next;};typedef struct Node Student_Node;typedef Student_Node * Link;/*=================================== =====创建链表==================================*/Link Creat_SequentialTable(Link Head){int Counter=1;Link New;Link Pointer;printf("Please input the number of the students: ");scanf("%d",&Number);Head=(Link)malloc(sizeof(Student_Node));Head->Name=(char*)malloc(10*sizeof(char) );Head->Class=(char*)malloc(10*sizeof(char) );printf("*-*-*-*Please input the Number、Name、Class、the Grade of C and DS*-*-*-*\n");scanf("%d%s%s%d%d",&Head->Number, Head->Name,Head->Class,&Head->Grade_C,& Head->Grade_DS);Head->Next=NULL;Pointer=Head;while(Counter<=(Number-1)){New=(Link)malloc(sizeof(Student_Node));if(!New)printf("\a Memory allocate failure!\n");New->Name=(char*)malloc(20*sizeof(char)) ;New->Class=(char*)malloc(20*sizeof(char));printf("*-*-*-*Please input the Number、Name、Class、the Grade of C and DS*-*-*-*\n");scanf("%d%s%s%d%d",&New->Number, New->Name,New->Class,&New->Grade_C,&Ne w->Grade_DS);New->Next=NULL;Pointer->Next=New;Pointer=New;Counter++;}return Head;}/*============================打印表============================*/void Print_SequentialTable(Link Head){Link Pointer;Pointer=Head;if(Pointer==NULL)printf("The table is empty!\n");printf("学号姓名班级 C 数据结构\n");while(Pointer!=NULL){printf("%d %s %s %d%d\n",Pointer->Number,Pointer->Name,Poi nter->Class,Pointer->Grade_C,Pointer->Grade_ DS);Pointer=Pointer->Next;}}/*===============================顺序查找===========================*/void Sequential_Search(Link Head,char * Name){int Counter=0;Link Pointer;//printf("Please input the name of the student you want to search")Pointer=Head;while(Pointer!=NULL){Counter++;if(*Name==*Pointer->Name){Counter--;printf("His(Her) information is:\nNumber:%d\nName:%s\nClass:%s\nGrade _C:%d\nGrade_DS:%d\n",Pointer->Number,Poi nter->Name,Pointer->Class,Pointer->Grade_C,P ointer->Grade_DS);}Pointer=Pointer->Next;}if(Counter==Number)printf("Search by Name------Not found!\n");}/*=================================折半查找=============================*/void Binary_Search(Link Head,int KeyNumber){Link Pointer;Pointer=Head;int Left;int Right;int Middle;Left=1;Right=Number;if(KeyNumber<1||KeyNumber>Number)printf("Search by Number----Not Found!\n");else{while(Left<=Right){Pointer=Head;Middle=(Left+Right)/2;for(int i=0;i<(Middle-1);i++){Pointer=Pointer->Next;}if(KeyNumber<Pointer->Number)Right=Pointer->Number;elseif(KeyNumber>Pointer->Number)Left=Pointer->Number;elseif(KeyNumber==Pointer->Number){printf("His(Her) informationis:\nNumber:%d\nName:%s\nClass:%s\nGrade _C:%d\nGrade_DS:%d\n",Pointer->Number,Poi nter->Name,Pointer->Class,Pointer->Grade_C,P ointer->Grade_DS);break;}}if(Left>Right)printf("Search by Number----Not Found!\n");}}/*=================================== =直接插入排序===========================*/void Insert_Sort(Link Head){printf("The table before sort: \n");Print_SequentialTable(Head);if(Head->Next==NULL)//此步条件判断非常有价值。
- 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;}三、实验心得（含上机中所遇问题的解决办法，所使用到的编程技巧、创新点及编程的心得）。