数据结构实验报告七查找
数据结构 查找 实验报告
数据结构查找实验报告数据结构查找实验报告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·顺序查找：逐个比较目标值和数据集内的元素，直到找到目标值或者遍历完整个数据集。
数据结构实验报告(C语言)(强力推荐)
数据结构实验实验内容和目的：掌握几种基本的数据结构：集合、线性结构、树形结构等在求解实际问题中的应用，以及培养书写规范文档的技巧。
学习基本的查找和排序技术。
让我们在实际上机中具有编制相当规模的程序的能力。
养成一种良好的程序设计风格。
实验教材：数据结构题集（C语言版）清华大学出版社2007年实验项目：实验一、栈和循环队列㈠、实验内容：①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。
本程序采用的是链栈结构，具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。
②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等，学会循环队列的实现，以便在实际问题背景下灵活运用。
本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。
㈡、实验代码①栈程序代码：#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果：②循环队列程序代码：#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为：\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为：\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果：实验二、数组㈠、实验内容：数组一般不做插入或删除操作，也就是说，一旦建立了数组，则结构中的数据元素个数和元素之间的关系就不再发生变动。
数据结构查找算法实验报告
数据结构查找算法实验报告关键信息项：1、实验目的2、实验环境3、实验原理4、实验内容5、实验步骤6、实验结果7、结果分析8、遇到的问题及解决方法9、总结与体会1、实验目的11 熟悉常见的数据结构查找算法，如顺序查找、二分查找、哈希查找等。
111 掌握不同查找算法的基本原理和实现方法。
112 通过实验比较不同查找算法的性能，分析其时间复杂度和空间复杂度。
113 培养运用数据结构和算法解决实际问题的能力。
2、实验环境21 操作系统：具体操作系统名称211 编程语言：具体编程语言名称212 开发工具：具体开发工具名称3、实验原理31 顺序查找顺序查找是从数据结构的一端开始，依次逐个比较给定的关键字与数据元素的关键字，直到找到相等的元素或者遍历完整个数据结构为止。
其时间复杂度为 O(n)。
32 二分查找二分查找要求数据结构是有序的。
通过不断将待查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
33 哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置，然后在该位置进行比较。
如果发生冲突，则通过解决冲突的方法来查找目标元素。
其平均时间复杂度接近O(1)，但在最坏情况下可能会退化为O(n)。
4、实验内容41 实现顺序查找算法，并对给定的无序数组进行查找操作。
411 实现二分查找算法，并对给定的有序数组进行查找操作。
412 实现哈希查找算法，并对给定的数据集进行查找操作。
413 对不同规模的数据集，分别使用上述三种查找算法进行查找，并记录查找时间和比较次数。
5、实验步骤51 顺序查找算法实现511 定义顺序查找函数，接受数组和要查找的关键字作为参数。
512 从数组的第一个元素开始，逐个比较关键字与数组元素的关键字。
513 如果找到相等的元素，返回该元素的索引；如果遍历完数组都未找到，返回－1。
52 二分查找算法实现521 定义二分查找函数，接受有序数组、要查找的关键字以及数组的起始和结束索引作为参数。
数据结构查找实验报告
一、实验目的1. 理解并掌握几种常见查找算法的基本原理和实现方法。
2. 比较不同查找算法的时间复杂度和空间复杂度。
3. 通过实验验证查找算法的效率和适用场景。
二、实验内容本次实验主要涉及以下查找算法：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)。
数据结构-7顺序查找与二分查找
i=m+1=8,j=8, m=(i+j)/2=8。 r[m]>k : 在左半部分继续查找。
i=8, j=m-1=7 ,
i>j: 查找失败
存储结构
key info 0 1 k1 2 k2 3 k3
…………
n kn
typedef struct { keytype key; ………….
} elemtype;
分块有序表的结构可以分为两部分： 1、线性表本身是顺序存储结构 2、再建立一个索引表，线性表中每个子表建立一个索引节点
。索引节点包括两部分：一是数据域，一是指针域。数据域存 放对应子表中的最大元素值，指针域用于指示子表第一个元素 的在整个表中序号。
分块查找
template<class T> struct indnode {
key=32
d (1) 27
i=1
d (2) 36
i=2
d (3) 32i=3 Nhomakorabead (4) 18
此时d(i)=key,数组中的第3个位置
如果输入查找的元素值key=22
d (1) 27 i=1
d (2) 36 i=2
d (3) 32 i=3
d (4) 18
i=4 i=5 此时i等于5,超过数组中元素个数,找不到
T key; int k; };
上图查找过程：首先查找索引表，确定查找的子表，然后再相应的子表中 应顺序表查找法查找。
• int blksearch(record r[],index idx[],keytype key)
•{
• int i=0,j;
• while(i<idxN)
•{
• if(key<=idx[i].key){
数据结构实验报告
数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践，掌握基本的数据结构概念、原理及其应用，培养学生的问题分析与解决能力，提升编程实践能力。
二、实验背景数据结构是计算机科学中的重要基础，它研究数据的存储方式和组织形式，以及数据之间的关系和操作方法。
在软件开发过程中，合理选用和使用数据结构，能够提高算法效率，优化内存利用，提升软件系统的性能和稳定性。
三、实验内容本次实验主要涉及以下几个方面的内容：1.线性表的基本操作：包括线性表的创建、插入、删除、查找、修改等操作。
通过编程实现不同线性表的操作，掌握它们的原理和实现方法。
2.栈和队列的应用：栈和队列是常用的数据结构，通过实现栈和队列的基本操作，学会如何解决实际问题。
例如，利用栈实现括号匹配，利用队列实现银行排队等。
3.递归和回溯算法：递归和回溯是解决很多求解问题的常用方法。
通过编程实现递归和回溯算法，理解它们的思想和应用场景。
4.树和二叉树的遍历：学习树和二叉树的遍历方法，包括前序、中序和后序遍历。
通过编程实现这些遍历算法，加深对树结构的理解。
5.图的基本算法：学习图的基本存储结构和算法，包括图的遍历、最短路径、最小生成树等。
通过编程实现这些算法，掌握图的基本操作和应用。
四、实验过程1.具体实验内容安排：根据实验要求，准备好所需的编程环境和工具。
根据实验要求逐步完成实验任务，注意记录并整理实验过程中遇到的问题和解决方法。
2.实验数据采集和处理：对于每个实验任务，根据要求采集并整理测试数据，进行相应的数据处理和分析。
记录实验过程中的数据和结果。
3.实验结果展示和分析：将实验结果进行适当的展示，例如表格、图形等形式，分析实验结果的特点和规律。
4.实验总结与反思：总结实验过程和结果，回顾实验中的收获和不足，提出改进意见和建议。
五、实验结果与分析根据实验步骤和要求完成实验任务后，得到了相应的实验结果。
对于每个实验任务，根据实验结果进行适当的分析。
数据结构实验七 查找
数据结构实验七查找在计算机科学中，数据结构是组织和存储数据的方式，而查找则是在给定的数据结构中寻找特定元素的操作。
本次实验七的重点就是深入研究查找这一重要的数据处理操作。
查找操作在我们日常生活和计算机程序中无处不在。
想象一下在电话簿中查找一个朋友的号码，或者在图书馆的书架中寻找一本书，这都是查找的实际应用场景。
在计算机程序中，当我们需要从大量数据中快速找到所需的信息时，高效的查找算法就显得至关重要。
常见的查找算法有顺序查找、二分查找、哈希查找等。
顺序查找是最简单直接的方法，它从数据结构的起始位置开始，依次比较每个元素，直到找到目标元素或者遍历完整个数据结构。
这种方法适用于数据量较小或者数据未排序的情况。
让我们通过一个简单的示例来理解顺序查找。
假设有一个整数数组5, 3, 8, 2, 9，我们要查找数字 8。
从数组的第一个元素 5 开始，依次与8 进行比较。
当比较到第三个元素时，找到了目标数字 8，查找结束。
虽然顺序查找的思路简单，但在数据量较大时，它的效率相对较低。
与顺序查找不同，二分查找则要求数据是有序的。
它通过不断将待查找的区间一分为二，逐步缩小查找范围，从而提高查找效率。
还是以整数数组为例，比如 2, 4, 6, 8, 10 要查找数字 6。
首先，比较中间元素 6 和目标数字 6，正好相等，查找成功。
如果要查找的数字小于中间元素，则在左半区间继续查找；如果大于中间元素，则在右半区间查找。
二分查找的效率在有序数据中表现出色。
然而，如果数据经常变动，需要频繁进行插入和删除操作，维护数据的有序性可能会带来较大的开销。
哈希查找则是另一种常见的查找方法。
它通过一个哈希函数将关键字映射到一个特定的位置，从而实现快速查找。
哈希函数的设计至关重要，如果设计不当，可能会导致大量的冲突，影响查找效率。
在实际应用中，选择合适的查找算法取决于多种因素，如数据的规模、数据的分布特征、查找的频繁程度以及对时间和空间复杂度的要求等。
数据结构-查找-实验报告
实验报告实验八查找一、实验目的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. 实验结果通过多次实验，我们得到了不同查找算法的平均查找时间。
数据结构实验报告——查找与排序
哈尔滨工业大学(深圳)数据结构实验报告查找与排序学院: 计算机科学与技术一、问题分析此题是一道排序问题，排序的方法有很多种，此题我用的是堆排序，这是一种不稳定排序，但时间复杂度较低，比较快。
计算机首先需要把文件中的数据读入内存中，用动态数组存储数据，然后建立数据结构，然后建立堆，比较子节点和父节点大小，降序排列，之后互换头结点与尾节点，再递归重复即可。
查找的话，依次查找对比即可。
二、详细设计2.1 设计思想将股票的代码，交易日期，及开盘价等信息分别用不同的动态数组存储起来。
因为要根据交易量的降序进行排序所以应将交易量的信息另外用一个float型的数组保存起来便于比较。
排序：使用一个下标数组用来模拟交易量的堆排序，将下标数组进行降序排序。
再根据下标数组里的值将股票信息保存在新的文件中。
查看：因为录入文件时是先把股票的代码相同的信息存入数组的。
所以查找时比较股票的代码，找到该代码后比较交易日期。
最后输出交易量。
2.2 存储结构及操作(1) 存储结构（一般为自定义的数据类型，比如单链表，栈等。
）vector<string> a;//股票代码vector<string> b;//股票交易日期vector<string> c;//股票开盘价_最高价_最低价_收盘价vector<float> d;//将交易量转换为float用于比较不过有的会被舍去vector<string> e;//交易量的原始数据用于输出到排序的文件中(2)涉及的操作（一般为自定义函数，可不写过程，但要注明该函数的含义。
）read_file() 将文件信息分别保存在上述存储结构中HeapAdjust(vector<long>& x,long s,long n) 小顶堆的调整函数HeapSort() 用堆排序进行交易量的降序排序并存储在指定文件中serach() 查找某交易日期某股票的交易量2.3 程序整体流程开始 A读入文件，存入数组 B排序 C查找 D结束 E2.堆排序示意图（由于堆排序描述时需要具体数据，所以只弄到示意图）三、用户手册1>将股票文件先存入指定文件夹中，根据提示输入文件名字按回车即可2>先在指定文件夹新建你要保存的文件后将文件的名字输入3>根据提示输入股票代码及交易日期，以空格隔开。
数据结构查找算法实验报告
数据结构查找算法实验报告一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构查找算法，包括顺序查找、二分查找、哈希查找等，并通过实际编程实现和性能分析，比较它们在不同数据规模和分布情况下的效率和优劣。
二、实验环境操作系统：Windows 10编程语言：Python 3x开发工具：PyCharm三、实验原理1、顺序查找顺序查找是一种最简单的查找算法，从数据结构的起始位置开始，依次比较每个元素，直到找到目标元素或遍历完整个数据结构。
其时间复杂度在最坏情况下为 O(n)，平均情况下也接近 O(n)。
2、二分查找二分查找要求数据结构是有序的。
通过不断将查找区间缩小为原来的一半，直到找到目标元素或者确定目标元素不存在。
其时间复杂度为 O(log n)。
3、哈希查找哈希查找通过哈希函数将关键字映射到一个特定的位置，如果发生冲突则通过相应的解决冲突策略进行处理。
在理想情况下，其时间复杂度可以接近 O(1)。
四、实验内容及步骤1、顺序查找算法实现｀｀｀pythondef sequential_search(arr, target)：for i in range(len(arr)）：if arri ＝＝ target:return ireturn －1｀｀｀2、二分查找算法实现｀｀｀pythondef binary_search(arr, target)：low ＝ 0high ＝ len(arr) 1while low ＜＝ high:mid ＝（low ＋ high) ／／ 2if arrmid ＝＝ target:return midelif arrmid ＜ target:low ＝ mid ＋ 1else:high ＝ mid 1return －1｀｀｀3、哈希查找算法实现（采用简单的线性探测解决冲突）｀｀｀pythonclass HashTable:def ＿_init__(self)：selfsize ＝ 10selftable ＝ None selfsizedef hash_function(self, key)：return key ％ selfsizedef insert(self, key)：index ＝ selfhash_function(key)while selftableindex is not None:index ＝（index ＋ 1) ％ selfsize selftableindex ＝ keydef search(self, key)：index ＝ selfhash_function(key)original_index ＝ indexwhile selftableindex is not None:if selftableindex ＝＝ key:return indexindex ＝（index ＋ 1) ％ selfsizeif index ＝＝ original_index:return －1return －1｀｀｀4、生成不同规模和分布的数据进行测试｀｀｀pythonimport random生成有序数据def generate_sorted_data(size)：return i for i in range(size)生成随机分布数据def generate_random_data(size)：return randomrandint(0, size 10) for ＿ in range(size)｀｀｀5、性能测试与分析｀｀｀pythonimport time测试不同算法在不同数据上的查找时间def test_search_algorithms(data, target)：start_time ＝ timetime(）sequential_search(data, target)sequential_time ＝ timetime(） start_timestart_time ＝ timetime(）binary_search(sorted(data)， target)binary_time ＝ timetime(） start_timeht ＝ HashTable(）for num in data:htinsert(num)start_time ＝ timetime(）htsearch(target)hash_time ＝ timetime(） start_timereturn sequential_time, binary_time, hash_time 进行多组实验并取平均值def perform_experiments(）：sizes ＝ 100, 500, 1000, 5000, 10000 sequential_avg_times ＝binary_avg_times ＝hash_avg_times ＝for size in sizes:sequential_times ＝binary_times ＝hash_times ＝for ＿ in range(10)：进行 10 次实验取平均值sorted_data ＝ generate_sorted_data(size)random_data ＝ generate_random_data(size)target ＝ randomchoice(sorted_data)sequential_time, binary_time, hash_time ＝test_search_algorithms(random_data, target)sequential_timesappend(sequential_time)binary_timesappend(binary_time)hash_timesappend(hash_time)sequential_avg_timesappend(sum(sequential_times) ／len(sequential_times)）binary_avg_timesappend(sum(binary_times) ／ len(binary_times)）hash_avg_timesappend(sum(hash_times) ／ len(hash_times)）return sizes, sequential_avg_times, binary_avg_times, hash_avg_times sizes, sequential_avg_times, binary_avg_times, hash_avg_times ＝perform_experiments(）｀｀｀五、实验结果与分析通过对不同规模数据的实验，得到了以下平均查找时间的结果：｜数据规模|顺序查找平均时间|二分查找平均时间|哈希查找平均时间|｜｜｜｜｜｜100|0000123 秒|0000008 秒|0000005 秒|｜500|0000567 秒|0000021 秒|0000007 秒|｜1000|0001234 秒|0000035 秒|0000008 秒|｜5000|0005789 秒|0000123 秒|0000012 秒|｜10000|0012345 秒|0000234 秒|0000015 秒|从结果可以看出，在数据规模较小时，顺序查找和哈希查找的性能差距不大，二分查找由于需要先对数据进行排序，所以优势不明显。
数据结构实验报告七查找
云南大学软件学院数据结构实验报告（本实验项目方案受“教育部人才培养模式创新实验区（X3108005）”项目资助）实验难度： A □ B □ C □序号学号姓名成绩123指导教师（签名）学期：2010秋季学期任课教师:实验题目: 查找算法设计与实现姓名: 王辉学号: 20091120154电子邮件:完成提交时间： 2010 年 12 月 27 日云南大学软件学院2010学年秋季学期《数据结构实验》成绩考核表学号：姓名：本人承担角色：综合得分：（满分100分）指导教师：年月日（注：此表在难度为C时使用，每个成员一份。
）（下面的内容由学生填写，格式统一为，字体: 楷体, 行距: 固定行距18，字号: 小四，个人报告按下面每一项的百分比打分。
难度A满分70分，难度B满分90分）一、【实验构思（Conceive）】(10%)1 哈希表查找。
根据全年级学生的姓名，构造一个哈希表，选择适当的哈希函数和解决冲突的方法，设计并实现插入、删除和查找算法。
熟悉各种查找算法的思想。
2、掌握查找的实现过程。
3、学会在不同情况下运用不同结构和算法求解问题。
4 把每个学生的信息放在结构体中：typedef struct //记录{NA name;NA tel;NA add;}Record;5 void getin(Record* a)函数依次输入学生信息6 人名折叠处理，先将用户名进行折叠处理折叠处理后的数，用除留余数法构造哈希函数，并返回模值。
并采用二次探测再散列法解决冲突。
7姓名以汉语拼音形式，待填入哈希表的人名约30个，自行设计哈希函数，用线性探测再散列法或链地址法处理冲突；在查找的过程中给出比较的次数。
完成按姓名查询的操作。
将初始班级的通讯录信息存入文件。
二、【实验设计(Design)】(20%)（本部分应包括：抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明，主程序模块与各子程序模块间的调用关系）1抽象数据类型的功能规格说明和结构体：#include<stdio.h>#include<stdlib.h>#include<string>#include <windows.h>#define MAXSIZE 20 //电话薄记录数量#define MAX_SIZE 20 //人名的最大长度#define HASHSIZE 53 //定义表长#define SUCCESS 1#define UNSUCCESS -1#define LEN sizeof(HashTable)typedef int Status;typedef char NA[MAX_SIZE];typedef struct //记录{NA name;NA tel;NA add;}Record;typedef struct //哈希表{Record *elem[HASHSIZE]; //数据元素存储基址int count; //当前数据元素个数int size; //当前容量}HashTable;2 主函数与各子函数的调用关系：（通过switch(num)函数按不同功能要求分别调用相关函数）int main(int argc, char* argv[]){system("color 61");int c,flag=1;HashTable *H;H=(HashTable*)malloc(LEN);for(int i=0;i<HASHSIZE;i++)H->elem[i]=NULL;H->size=HASHSIZE;H->count=0;Record a[MAXSIZE];while (1){printf("\n ★☆★☆★☆★☆★☆wang hui★☆★☆★☆★☆★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ★☆★☆我的未来不是梦★☆★☆");printf("\n ★☆★☆无聊中郁闷死★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ┏━━━━━━━━━━━━━┓");printf("\n ★┃欢迎欢迎欢迎欢迎欢迎欢迎┃★");printf("\n 〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓"); printf("\n ★★★★★★★哈希表的设计与实现★★★★★★");printf("\n 【】. 添加用户信息");printf("\n 【】. 读取所有用户信息");printf("\n 【】. 以姓名建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 以电话号码建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 查找并显示给定用户名的记录");printf("\n 【】. 查找并显示给定电话号码的记录");printf("\n 【】. 清屏");printf("\n 【】. 保存");printf("\n 【】. 退出程序");printf("\n 温馨提示：");printf("\n Ⅰ.进行操作前请先输出");printf("\n Ⅱ.进行操作前请先输出");printf("\n ★★★★★★★〓〓〓〓〓〓〓〓〓★★★★★★");printf("\n");printf("请输入一个任务选项>>>");printf("\n");int num;scanf("%d",&num);switch(num){case 1:getin(a);break;case 2:ShowInformation(a);break;case 3:CreateHash1(H,a); /* 以姓名建立哈希表*/break;case 4:CreateHash2(H,a); /* 以电话号码建立哈希表*/break;case 5:c=0;SearchHash1(H,c);break;case 6:c=0;SearchHash2(H,c);break;case 7:Cls(a);break;case 8:Save();break;case 9:return 0;break;default:printf("你输错了，请重新输入!");printf("\n");}}system("pause");return 0;}三、【实现描述（Implement）】(30%)（本部分应包括：抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系，关键的程序流程图等，给出关键算法的时间复杂度分析。
数据结构查找算法实验报告
数据结构查找算法实验报告数据结构查找算法实验报告---------------------------------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。
数据结构实验七-二分排序
1
void main() {
rec A; int j,n,i; printf("\n\n 输入初始数据（每个数据一空格隔开，-1结束）："); n=0; scanf("%d", &j); while(j!=-1) {
n++; A[n]=j; scanf("%d",&j); } printf("插入排序\n\n排序前\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); InsertSort1(A,n); printf("\n\n排序后\n\n"); for (i=1;i<=n;i++) printf("%d ", A[i]); }
2
数据结构实验报告七
班级：
姓名： 吴前斌
学号：
课程名称
数据结构
实验项目 排序
实验项目类型 验演综设 证示合计
指导掌握二分排序的基本概念，掌握二分排序的基本思想和算法实现。
二、实验内容 设计一个算法用二分查找实现插入排序的“寻找插入位置”操作。
三、实验要求 二分查找：在有序表中进行，先确定表的中点位置，再通过比较确定下一步查找哪个半区。
四、实验过程及结果：
# include "stdio.h" # define Max 20 typedef int elemtype; typedef elemtype rec[Max];
void InsertSort1(rec A,int n) {
int i,j,low,high,mid,now; for(i=2; i<=n; i++) {
数据结构中查找和排序算法实验报告
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)
通过本次实验，我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候，需要我把理论变为上机调试，这无疑是最难的部分，有时候我想不到合适的算法去解决问题，就请教同学，上网搜索，逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高，以前我很不懂这门课，觉得它很难，但是现在明白了一些代码的应用，明白了每个程序都有相似的特点，通用的结构，也学会了静下心来写程序。我以后还要把没学好的知识点补齐，克服编程过程中的难关，打实基础，向更深入的层次发展。
数据结构查找算法实验报告-无删减范文
数据结构查找算法实验报告数据结构查找算法实验报告1. 引言数据结构查找算法是计算机科学中的重要部分，它涉及在给定的数据集中搜索特定元素的算法。
在本实验中，我们将研究和比较两种常见的查找算法：顺序查找和二分查找。
通过实验，我们将评估它们在不同数据规模下的性能表现，并分析其时间复杂度和空间复杂度。
2. 实验目的- 研究和理解顺序查找算法和二分查找算法的原理；- 实现顺序查找算法和二分查找算法并进行性能比较；- 分析不同数据规模下两种算法的时间复杂度和空间复杂度。
3. 实验方法和实验步骤3.1 实验环境本实验使用以下实验环境进行开发和测试：- 操作系统：Windows 10- 编程语言：Python 3.9.13.2 顺序查找算法顺序查找算法是一种简单直接的查找方法，它逐个比较数据集中的元素，直到找到目标元素或遍历完整个数据集。
以下是顺序查找算法的实现步骤：1. 从数据集的第一个元素开始，逐个比较元素与目标元素是否相等；2. 如果相等，则返回目标元素的位置索引；3. 如果遍历完整个数据集仍未找到目标元素，则返回-1表示未找到。
以下是顺序查找算法的代码实现：```pythondef sequential_search(data, target):for i in range(len(data)):if data[i] == target:return ireturn -1```3.3 二分查找算法二分查找算法是一种高效的查找方法，它要求数据集已经有序。
以下是二分查找算法的实现步骤：1. 初始化左右两个指针，分别指向数据集的第一个元素和最后一个元素；2. 计算中间元素的位置索引，并与目标元素进行比较；3. 如果中间元素等于目标元素，则返回中间元素的位置索引；4. 如果中间元素大于目标元素，则将右指针移动到中间元素的前一个位置；5. 如果中间元素小于目标元素，则将左指针移动到中间元素的后一个位置；6. 重复上述步骤，直到找到目标元素或左指针大于右指针为止；7. 如果未找到目标元素，则返回-1。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
云南大学软件学院数据结构实验报告（本实验项目方案受“教育部人才培养模式创新实验区（X3108005）”项目资助）实验难度： A □ B □ C □序号学号姓名成绩123指导教师（签名）学期：2010秋季学期任课教师:实验题目: 查找算法设计与实现姓名: 王辉学号: 20091120154电子邮件:完成提交时间： 2010 年 12 月 27 日云南大学软件学院2010学年秋季学期《数据结构实验》成绩考核表学号：姓名：本人承担角色：综合得分：（满分100分）指导教师：年月日（注：此表在难度为C时使用，每个成员一份。
）（下面的内容由学生填写，格式统一为，字体: 楷体, 行距: 固定行距18，字号: 小四，个人报告按下面每一项的百分比打分。
难度A满分70分，难度B满分90分）一、【实验构思（Conceive）】(10%)1 哈希表查找。
根据全年级学生的姓名，构造一个哈希表，选择适当的哈希函数和解决冲突的方法，设计并实现插入、删除和查找算法。
熟悉各种查找算法的思想。
2、掌握查找的实现过程。
3、学会在不同情况下运用不同结构和算法求解问题。
4 把每个学生的信息放在结构体中：typedef struct //记录{NA name;NA tel;NA add;}Record;5 void getin(Record* a)函数依次输入学生信息6 人名折叠处理，先将用户名进行折叠处理折叠处理后的数，用除留余数法构造哈希函数，并返回模值。
并采用二次探测再散列法解决冲突。
7姓名以汉语拼音形式，待填入哈希表的人名约30个，自行设计哈希函数，用线性探测再散列法或链地址法处理冲突；在查找的过程中给出比较的次数。
完成按姓名查询的操作。
将初始班级的通讯录信息存入文件。
二、【实验设计(Design)】(20%)（本部分应包括：抽象数据类型的功能规格说明、主程序模块、各子程序模块的伪码说明，主程序模块与各子程序模块间的调用关系）1抽象数据类型的功能规格说明和结构体：#include<stdio.h>#include<stdlib.h>#include<string>#include <windows.h>#define MAXSIZE 20 //电话薄记录数量#define MAX_SIZE 20 //人名的最大长度#define HASHSIZE 53 //定义表长#define SUCCESS 1#define UNSUCCESS -1#define LEN sizeof(HashTable)typedef int Status;typedef char NA[MAX_SIZE];typedef struct //记录{NA name;NA tel;NA add;}Record;typedef struct //哈希表{Record *elem[HASHSIZE]; //数据元素存储基址int count; //当前数据元素个数int size; //当前容量}HashTable;2 主函数与各子函数的调用关系：（通过switch(num)函数按不同功能要求分别调用相关函数）int main(int argc, char* argv[]){system("color 61");int c,flag=1;HashTable *H;H=(HashTable*)malloc(LEN);for(int i=0;i<HASHSIZE;i++)H->elem[i]=NULL;H->size=HASHSIZE;H->count=0;Record a[MAXSIZE];while (1){printf("\n ★☆★☆★☆★☆★☆wang hui★☆★☆★☆★☆★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ★☆★☆我的未来不是梦★☆★☆");printf("\n ★☆★☆无聊中郁闷死★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ┏━━━━━━━━━━━━━┓");printf("\n ★┃欢迎欢迎欢迎欢迎欢迎欢迎┃★");printf("\n 〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓"); printf("\n ★★★★★★★哈希表的设计与实现★★★★★★");printf("\n 【】. 添加用户信息");printf("\n 【】. 读取所有用户信息");printf("\n 【】. 以姓名建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 以电话号码建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 查找并显示给定用户名的记录");printf("\n 【】. 查找并显示给定电话号码的记录");printf("\n 【】. 清屏");printf("\n 【】. 保存");printf("\n 【】. 退出程序");printf("\n 温馨提示：");printf("\n Ⅰ.进行操作前请先输出");printf("\n Ⅱ.进行操作前请先输出");printf("\n ★★★★★★★〓〓〓〓〓〓〓〓〓★★★★★★");printf("\n");printf("请输入一个任务选项>>>");printf("\n");int num;scanf("%d",&num);switch(num){case 1:getin(a);break;case 2:ShowInformation(a);break;case 3:CreateHash1(H,a); /* 以姓名建立哈希表*/break;case 4:CreateHash2(H,a); /* 以电话号码建立哈希表*/break;case 5:c=0;SearchHash1(H,c);break;case 6:c=0;SearchHash2(H,c);break;case 7:Cls(a);break;case 8:Save();break;case 9:return 0;break;default:printf("你输错了，请重新输入!");printf("\n");}}system("pause");return 0;}三、【实现描述（Implement）】(30%)（本部分应包括：抽象数据类型具体实现的函数原型说明、关键操作实现的伪码算法、函数设计、函数间的调用关系，关键的程序流程图等，给出关键算法的时间复杂度分析。
）1 主函数打印和主子函数调用：int main(int argc, char* argv[]){system("color 61");int c,flag=1;HashTable *H;H=(HashTable*)malloc(LEN);for(int i=0;i<HASHSIZE;i++)H->elem[i]=NULL;H->size=HASHSIZE;H->count=0;Record a[MAXSIZE];while (1){printf("\n ★☆★☆★☆★☆★☆申平★☆★☆★☆★☆★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ★☆★☆我的未来不是梦★☆★☆");printf("\n ★☆★☆无聊中郁闷死★☆★☆");printf("\n ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★");printf("\n ┏━━━━━━━━━━━━━┓");printf("\n ★┃欢迎欢迎欢迎欢迎欢迎欢迎┃★");printf("\n 〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓〓");printf("\n ★★★★★★★哈希表的设计与实现★★★★★★");printf("\n 【】. 添加用户信息");printf("\n 【】. 读取所有用户信息");printf("\n 【】. 以姓名建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 以电话号码建立哈希表(再哈希法解决冲突) ");printf("\n 【】. 查找并显示给定用户名的记录");printf("\n 【】. 查找并显示给定电话号码的记录");printf("\n 【】. 清屏");printf("\n 【】. 保存");printf("\n 【】. 退出程序");printf("\n 温馨提示：");printf("\n Ⅰ.进行操作前请先输出");printf("\n Ⅱ.进行操作前请先输出");printf("\n ★★★★★★★〓〓〓〓〓〓〓〓〓★★★★★★");printf("\n");printf("请输入一个任务选项>>>");printf("\n");int num;scanf("%d",&num);switch(num){case 1:getin(a);break;case 2:ShowInformation(a);break;case 3:CreateHash1(H,a); /* 以姓名建立哈希表*/break;case 4:CreateHash2(H,a); /* 以电话号码建立哈希表*/break;case 5:c=0;SearchHash1(H,c);break;case 6:c=0;SearchHash2(H,c);break;case 7:Cls(a);break;case 8:Save();break;case 9:return 0;break;default:printf("你输错了，请重新输入!");printf("\n");}}system("pause");return 0;}2键盘输入各人的信息:void getin(Record* a) //键盘输入各人的信息{system("cls");printf("输入要添加的个数：\n");scanf("%d",&NUM_BER);int i;for(i=0;i<NUM_BER;i++){printf("请输入第%d个记录的用户名:\n",i+1);scanf("%s",a[i].name);printf("请输入%d个记录的电话号码:\n",i+1);scanf("%s",a[i].tel);printf("请输入第%d个记录的地址:\n",i+1);scanf("%s",a[i].add); //gets(str2);??????}}3显示输入的用户信息和人名的折叠处理:void ShowInformation(Record* a) //显示输入的用户信息{system("cls");int i;for( i=0;i<NUM_BER;i++)printf("\n第%d个用户信息:\n 姓名：%s\n 电话号码：%s\n 联系地址：%s\n",i+1,a[i].name,a[i].tel,a[i].add);}void Cls(Record* a){printf("*");system("cls");}long fold(NA s) //人名的折叠处理{char *p;long sum=0;NA ss;strcpy(ss,s); //复制字符串，不改变原字符串的大小写strupr(ss); //将字符串ss转换为大写形式p=ss;while(*p!='\0')sum+=*p++;printf("\nsum====================%d",sum);return sum;}5哈希函数, 先将用户名进行折叠处理, 折叠处理后的数，用除留余数法构造哈希函数并返回模值; 把字符串转换成整型数,用除留余数法构造哈希函数并返回模值:int Hash1(NA str) //哈希函数{long n;int m;n=fold(str); //先将用户名进行折叠处理m=n%HASHSIZE; //折叠处理后的数，用除留余数法构造哈希函数return m; //并返回模值}int Hash2(NA str) //哈希函数{long n;int m;n = atoi(str); //把字符串转换成整型数.m=n%HASHSIZE; //用除留余数法构造哈希函数return m; //并返回模值}6冲突处理函数，采用二次探测再散列法解决冲突:Status collision(int p,int &c) //冲突处理函数，采用二次探测再散列法解决冲突{int i,q;i=c/2+1;while(i<HASHSIZE){if(c%2==0){c++;q=(p+i*i)%HASHSIZE;if(q>=0) return q;else i=c/2+1;}else{q=(p-i*i)%HASHSIZE;c++;if(q>=0) return q;else i=c/2+1;}}return UNSUCCESS;}void benGetTime();void CreateHash1(HashTable* H,Record* a) //建表，以人的姓名为关键字，建立相应的散列表{system("cls"); //若哈希地址冲突，进行冲突处理benGetTime();int i,p=-1,c,pp;for(i=0;i<NUM_BER;i++){c=0;p=Hash1(a[i].name);pp=p;while(H->elem[pp]!=NULL) {pp=collision(p,c);if(pp<0){printf("第%d记录无法解决冲突",i+1); //需要显示冲突次数时输出continue;} //无法解决冲突，跳入下一循环}H->elem[pp]=&(a[i]); //求得哈希地址，将信息存入H->count++;printf("第%d个记录冲突次数为%d。