数据结构:查找实验
数据结构 查找 实验报告

数据结构查找实验报告数据结构查找实验报告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·顺序查找:逐个比较目标值和数据集内的元素,直到找到目标值或者遍历完整个数据集。
数据结构实验 查找

实验4查找一、实验目的或任务通过指导学生上机实践,对常用数据结构的基本概念及其不同的实现方法的理论得到进一步的掌握,并对在不同存储结构上实现不同的运算方式和技巧有所体会。
二、实验教学基本要求1.了解实验目的及实验原理;2.编写程序,并附上程序代码和结果图;3.总结在编程过程中遇到的问题、解决办法和收获。
三、实验教学的内容或要求1.编写函数,建立有序表,采用折半查找实现某一已知的关键字的查找(采用顺序表存储结构)2.编写函数,随机产生一组关键字,利用二叉排序树的插入算法建立二叉排序树3.编写函数,在以上二叉排序树中删除某一指定关键字元素4.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法四、实验类型或性质验证性五、实验开出要求必做六、实验所需仪器设备1.计算机2.相关软件(如C,C++,PASCAL,VC,DELPHI等等)七、实验所用材料计算机耗材一、程序运行界面:二、源程序#define _CRT_SECURE_NO_W ARNINGS#include<stdio.h>#include<malloc.h>#define MAXNODE 256typedefstruct Node{int data;struct Node *lchild,*rchild;}NodeType;typedefstruct{int num;}datatype;typedefstruct{datatype *data;int length;}S_TBL;int SearchData(NodeType *T,NodeType **p,NodeType **q,int kx) {int flag=0;*q=T;while(*q){if(kx>(*q)->data){*p=*q;*q=(*q)->rchild;}else{if(kx<(*q)->data){*p=*q;*q=(*q)->lchild;}else{flag=1;break;}}}return flag;}int InsertNode(NodeType **T,int kx){int flag=0;NodeType *p=*T,*q,*s;if(!SearchData(*T,&p,&q,kx)){s=(NodeType*)malloc(sizeof(NodeType));s->data=kx;s->lchild=NULL;s->rchild=NULL;if(p==NULL){*T=s;}else{if(kx>p->data){p->rchild=s;}else{p->lchild=s;}}flag=1;}return flag;}int DeleteNode(NodeType **T,int kx) {int flag=0;NodeType *p=*T,*q,*s,**f;if(SearchData(*T,&p,&q,kx)){if(p==q){f=T;}else{f=&(p->lchild);if(kx>p->data){f=&(p->rchild);}}if(q->rchild==NULL){*f=q->lchild;}else{if(q->lchild==NULL){*f=q->rchild;}else{p=q->rchild;s=p;while(p->lchild){s=p; p=p->lchild;}*f=p;p->lchild=q->lchild;if(s!=p){s->lchild=p->rchild;p->rchild=q->rchild;}}}free(q);flag=1;}return flag;}void InOrder(NodeType *bt){if(bt==NULL) return;InOrder(bt->lchild);printf("%3d",bt->data);InOrder(bt->rchild);}/*折半查找*/int Binary_Search(S_TBL *tbl,int kx){int low,high,mid,flag;flag=0;low=1;high=tbl->length;while(low<=high){mid=(low+high)/2;if(kx<tbl->data[mid].num){high=mid-1;}elseif(kx>tbl->data[mid].num){low=mid+1;}else{flag=mid; break;}}return flag;}/*主菜单*/void menu(){printf("1、插入并建立二叉树\n");printf("2、删除二叉树上的结点\n");printf("3、中序遍历二叉树\n");printf("4、折半查找\n");printf("0、退出\n");}void main(){int n,m=1;NodeType *T=NULL;menu();while(m){printf("请输入选项:");scanf("%d",&n);switch(n){case 1:{/*插入并建立二叉树*/int flag;int kx;printf("请输入一组数据以-1结尾:");scanf("%d",&kx);while(kx!=-1){flag=InsertNode(&T,kx);if(flag==0){printf("插入失败!\n");break;}scanf("%d",&kx);}break;}case 2:{/*删除二叉树上的结点*/int flag;int kx;printf("请输入要删除的数:");scanf("%d",&kx);flag=DeleteNode(&T,kx);if(flag==0){printf("删除失败!\n");}else{printf("删除成功!\n");}break;}case 3:{InOrder(T);printf("\n");break;}case 4:{int i,flag;int kx;S_TBL *tbl=(S_TBL *)malloc(sizeof(S_TBL));printf("请输入长度:");scanf("%d",&(tbl->length));tbl->data=(datatype *)calloc( tbl->length, sizeof(datatype) );printf("请输入元素:");for(i=1;i<=tbl->length;i++){scanf("%d",&((tbl->data[i]).num));}printf("请输入你要查找的数:");scanf("%d",&kx);flag=Binary_Search(tbl,kx);if(flag==0){printf("查找失败!\n");}else{printf("位置=%6d\n",flag);}break;}case 0:{m=0;break;}}}}三、实验总结通过本次实验,我对常用数据结构的基本概念及其不同的实现方法的理论得到进一步的掌握,并对用折半查找实现某一已知的关键字的查找有了较为深刻的认识,同时对用二叉排序树的插入算法建立二叉排序树,以及在二叉排序树中删除某一指定关键字元素的具体操作也自己动手实践了。
数据结构实验七 查找

数据结构实验七查找数据结构实验七查找一、实验目的本实验旨在通过编程实现常见的查找算法,包括顺序查找、二分查找和哈希查找,并比较它们的效率和适用场景。
二、实验内容1.顺序查找1.1 算法思想顺序查找算法是一种简单直观的查找方法,它的基本思想是从数组的第一个元素开始逐个比较,直到找到目标元素或遍历完整个数组。
1.2 算法流程a) 初始化目标元素的索引为 -1.b) 从数组的第一个元素开始,依次与目标元素比较。
c) 如果找到目标元素,则记录其索引,并结束查找。
d) 如果遍历完整个数组仍未找到目标元素,则记录目标索引仍为 -1.1.3 时间复杂度顺序查找算法的时间复杂度为 O(n),其中 n 为数组的长度。
2.二分查找2.1 算法思想二分查找算法是一种高效的查找算法,但要求被查找的数组必须是有序的。
它的基本思想是将目标元素与数组的中间元素进行比较,然后根据比较结果将查找的范围缩小一半,直到找到目标元素或查找范围为空。
2.2 算法流程a) 初始化目标元素的索引为 -1、查找范围的起始索引为0,终止索引为数组长度减一。
b) 计算查找范围的中间索引,取整数部分。
c) 将目标元素与中间索引对应的数组元素进行比较:- 如果相等,则记录中间索引为目标索引,并结束查找。
- 如果目标元素小于中间元素,则在前一半查找范围中进行二分查找。
- 如果目标元素大于中间元素,则在后一半查找范围中进行二分查找。
d) 如果查找范围的起始索引大于终止索引,则表示查找范围为空,记录目标索引仍为 -1.2.3 时间复杂度二分查找算法的时间复杂度为 O(log n),其中 n 为数组的长度。
3.哈希查找3.1 算法思想哈希查找算法利用哈希函数将关键字映射到一个固定位置进行查找,从而实现快速访问。
它的基本思想是通过哈希函数计算得到关键字的哈希值,并根据哈希值找到对应的存储位置,如果哈希表中已经存在该关键字,则返回对应的值,否则返回空。
3.2 算法流程a) 初始化一个哈希表,用于存储关键字和对应值的映射。
数据结构查找算法实验报告

数据结构查找算法实验报告关键信息项: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)。
数据结构查找算法实验报告

数据结构实验报告实验第四章:实验:简单查找算法一.需求与规格说明:查找算法这里主要使用了顺序查找,折半查找,二叉排序树查找与哈希表查找四种方法。
由于自己能力有限,本想实现其她算法,但没有实现.其中顺序查找相对比较简单,折半查找参考了书上得算法,二叉排序树查找由于有之前做二叉树得经验,因此实现得较为顺利,哈希表感觉做得并不成功,感觉还就是应该可以进一步完善,应该说还有很大得改进余地。
二.设计思想:开始得时候提示输入一组数据。
并存入一维数组中,接下来调用一系列查找算法对其进行处理。
顺序查找只就是从头到尾进行遍历。
二分查找则就是先对数据进行排序,然后利用三个标志,分别指向最大,中间与最小数据,接下来根据待查找数据与中间数据得比较不断移动标志,直至找到。
二叉排序树则就是先构造,构造部分花费最多得精力,比根节点数据大得结点放入根节点得右子树,比根节点数据小得放入根节点得左子树,其实完全可以利用递归实现,这里使用得循环来实现得,感觉这里可以尝试用递归.当二叉树建好后,中序遍历序列即为由小到大得有序序列,查找次数不会超过二叉树得深度。
这里还使用了广义表输出二叉树,以使得更直观。
哈希表则就是利用给定得函数式建立索引,方便查找.三.设计表示:四.实现注释:其实查找排序这部分与前面得一些知识联系得比较紧密,例如顺序表得建立与实现,顺序表节点得排序,二叉树得生成与遍历,这里主要就是中序遍历.应该说有些知识点较为熟悉,但在实现得时候并不就是那么顺利。
在查找到数据得时候要想办法输出查找过程得相关信息,并统计。
这里顺序查找与折半查找均使用了数组存储得顺序表,而二叉树则就是采用了链表存储得树形结构。
为了直观起见,在用户输入了数据后,分别输出已经生成得数组与树。
折半查找由于只能查找有序表,因此在查找前先调用函数对数据进行了排序。
在查找后对查找数据进行了统计.二叉排序树应该说由于有了之前二叉树得基础,并没有费太大力气,主要就是在构造二叉树得时候,要对新加入得节点数据与跟数据进行比较,如果比根节点数据大则放在右子树里,如果比根节点数据小则放入左子树。
数据结构实验五---查找的实现
实验五查找得实现一、实验内容1、建立一个线性表,对表中数据元素存放得先后次序没有任何要求.输入待查数据元素得关键字进行查找。
为了简化算法,数据元素只含一个整型关键字字段,数据元素得其余数据部分忽略不考虑.建议采用前哨得作用,以提高查找效率。
2、查找表得存储结构为有序表,输入待查数据元素得关键字利用折半查找方法进行查找.此程序中要求对整型量关键字数据得输入按从小到大排序输入。
二、源代码与执行结果1、#include〈iostream>using namespace std;#define MAX 100#define KeyType inttypedef struct{KeyType key ;}DataType;typedef struct{ﻩDataType elem[MAX] ;intlength ;}SeqTable ,*PSeqTable ;PSeqTable Init_SeqTable(){ﻩPSeqTable p =(PSeqTable)malloc(sizeof(SeqTable)) ;ﻩif(p !=NULL){p->length = 0 ;ﻩreturnp;}ﻩelse{ﻩcout〈<"Outof space!”〈〈endl ;ﻩreturn NULL;ﻩ}}int insert_SeqTable(PSeqTable p,KeyType x){if(p->length〉= MAX)ﻩ{ﻩcout〈<”overflow!"<<endl ;ﻩreturn 0 ;ﻩ}p—>elem[p—>length]、key= x ;p-〉length++;return 1 ;}int SeqSearch(SeqTable s ,KeyTypek){ﻩint n , i = 0;ﻩn = s、length ;s、elem[n]、key =k ;ﻩwhile(s、elem[i]、key != k)ﻩﻩi ++ ;ﻩif(i == n)return —1 ;elseﻩﻩreturn i ;}voidmain(){PSeqTable p ;inti , n;ﻩKeyType a ;p =Init_SeqTable();ﻩcout<〈"请输入数据个数:" ;cin>>n ;cout〈<"请输入数据:”<〈endl ;for(i = 0 ; i< n ;i++)ﻩ{ﻩcin〉>a ;ﻩinsert_SeqTable(p , a);}ﻩcout<<"请输入要查找得数据,输入32767结束:” ;cin〉〉a ;ﻩwhile(a != 32767)ﻩ{i =SeqSearch(*p, a) ;if(i == -1){ﻩﻩﻩcout<<”无此数据!请重新输入:"<〈endl ;ﻩﻩcin>>a ;ﻩ}ﻩﻩelseﻩﻩ{ﻩcout<〈"该数据得位置就是:"〈<i+1<<endl;ﻩcout〈<"请输入要查找得数据:" ;ﻩﻩcin〉〉a;ﻩ}ﻩ}}2、#include<iostream>using namespace std;#define MAX 100#define KeyType inttypedef struct{KeyType key ;}DataType;typedef struct{ﻩDataType elem[MAX] ;ﻩint length ;}BinTable ,*PBinTable ;PBinTable Init_BinTable(){ﻩPBinTable p = (PBinTable)malloc(sizeof(BinTable)) ;if(p != NULL){p->length= 0;ﻩﻩreturn p ;ﻩ}elseﻩ{ﻩcout〈<"Out of space!"〈<endl ;return NULL ;ﻩ}}int insert_BinTable(PBinTable p ,KeyType x){if(p—〉length >= MAX){ﻩcout<<"overflow!”<〈endl ;ﻩreturn 0 ;ﻩ}ﻩp-〉elem[p—>length]、key =x ;p->length ++ ;ﻩreturn 1;}int BinSearch(BinTable s ,KeyType k){ﻩint low,mid , high;ﻩlow = 0 ;high = s、length-1 ;while(low <= high){ﻩﻩmid=(low+high)/2 ;ﻩif(s、elem[mid]、key== k)ﻩﻩﻩreturnmid;ﻩelse if(s、elem[mid]、key >k)ﻩﻩhigh= mid- 1 ;ﻩﻩelseﻩlow = mid +1 ;ﻩ}ﻩreturn —1;}void main(){PBinTable p ;ﻩinti ,n ;ﻩKeyType a;p =Init_BinTable();cout<<”请输入数据个数:”;cin〉>n;ﻩcout<〈"请按从小到大得顺序输入数据:”〈<endl;for(i = 0 ;i〈 n; i ++)ﻩ{cin>〉a;ﻩinsert_BinTable(p,a);}ﻩcout<<"请输入要查找得数据,输入32767结束:” ;ﻩcin〉>a ;while(a!= 32767){ﻩi =BinSearch(*p , a);if(i ==-1)ﻩ{ﻩﻩcout〈〈"无此数据!请重新输入:"〈〈endl ;cin>>a;ﻩ}ﻩelse{ﻩcout<<"该数据得位置就是:”〈<i+1〈<endl ;ﻩﻩﻩcout<〈”请输入要查找得数据:" ;cin>〉a ;}ﻩ}}。
数据结构实验七 查找
数据结构实验七查找在计算机科学中,数据结构是组织和存储数据的方式,而查找则是在给定的数据结构中寻找特定元素的操作。
本次实验七的重点就是深入研究查找这一重要的数据处理操作。
查找操作在我们日常生活和计算机程序中无处不在。
想象一下在电话簿中查找一个朋友的号码,或者在图书馆的书架中寻找一本书,这都是查找的实际应用场景。
在计算机程序中,当我们需要从大量数据中快速找到所需的信息时,高效的查找算法就显得至关重要。
常见的查找算法有顺序查找、二分查找、哈希查找等。
顺序查找是最简单直接的方法,它从数据结构的起始位置开始,依次比较每个元素,直到找到目标元素或者遍历完整个数据结构。
这种方法适用于数据量较小或者数据未排序的情况。
让我们通过一个简单的示例来理解顺序查找。
假设有一个整数数组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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构实验报告
课程数据结构实验实验名称查找
系别计算机学院专业班级组别_____________
一.实验目的:
1.掌握顺序查找,二分查找的算法
2.能运用线性表的查找方法解决实际问题
二.实验内容
(-)实验题目一:写给出一个无序表A中采用顺序查找算法查找值为x的元素的算法
1.要点分析:
顺序查找首先从表的先端开始,依次与给定值x进行比较,直达找到与其相等的元素值,返回该元素值的下标,查找成功。
否则给出查找失败信息。
2.程序源代码:
#include<stdio.h>
#define N 10
int search(int A[],int x,int n)
{
int i=0;
while(i<n&&A[i]!=x) //找遍且找到
i++;
if(i>=n)
return -1;
else
return i;
}
void main()
{
int a[N]={2,38,42,44,25,12,3,1,23,89},d,i,k;
printf("A数组下标:\n");
for(i=0;i<N;i++)
printf("%d ",i);
printf("\n");
printf("A数组值:\n");
for(i=0;i<N;i++)
printf("%d ",a[i]);
printf("\n输入要查找的值:");
scanf("%d",&d);
k=search(a,d,N);
if(k>=0)
printf("a[%d]=%d\n",k,d);
else
printf("%d未找到\n",d); }
3.实验结果
(二)实验题目二:编写一个算法,利用二分查找算法在一个有序表中插入一个元素x,并保持表的有序性。
1.要点分析:
首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。
重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。
2.程序源代码:
#include <stdio.h>
#include <string.h>
#define maxnum 100
int input(int *); //输入数据
int search(int *,int,int); //查找插入位置
void plug(int *,int,int); //插入数据
void main()
{
int data[maxnum],m;
int insert=1;
m=input(data);
printf("请输入要插入的数据: \n"); //输入插入的数据
scanf("%d",data); //输入插入的数据存放在data数组0号位置insert=search(data,1,m); //找到数据要插入的位置
plug(data,insert,m); //运用递归的方法插入数据
printf("最后结果: \n");
for(insert=1;insert<=m+1;insert++)
printf("%d ",*(data+insert));
getchar();
}
int input(int * data)
{
int i,m;
printf("请输入该有序表的长度: \n");
scanf("%d",&m);
printf("请按大小顺序输入%d个数据 \n",m);
for(i=1;i<=m;i++)
scanf("%d",data+i);
return m;
}
int search(int *data,int low,int high)
{
int mid;
if(low>high) //没有找到插入位置
return low;
else
{
mid=(low+high)/2;
if(*(data+mid)== *data)
return mid;
else if(*(data+mid)<*data)
low=mid+1;
else if(*(data+mid)>*data)
high=mid-1;
}
search(data,low,high);
}
void plug(int *data,int insert,int m) //移动并插入数据{
int i;
for(i=m;i>=insert;i--)
*(data+i+1)=*(data+i);
*(data+insert)=*data;
}
3.实验结果
(三)实验题目:设计一个算法,读入一串整数,构造其对应的二叉排序树
1.要点分析
二叉排序树的递归式定义。
二叉排序树又称二叉查找树,它可以是一棵空树,若非空时具有下述性质:
1、若根结点的左子树非空,则左子树上所有结点的关键字值均小于等于根结点的关键字值。
2、若根结点的右子树非空,则右子树上所有结点的关键字值均大于等于根结点的关键字值。
3、根结点的左、右子树也分别为二叉排序树。
二叉排序树建立说明:
当需要插入一个节点到二叉排序树时,需要先找到它的父节点。
其实它就是用插入的节点不断的和每一个节点比较(第一次当然是和根节点比较啦),如果小于等于则进入左边子树,再与左边子树的根节点比较,直到找到它要放的位置,
否则进入右子树,进行上述操作
2.源程序代码
#include<stdio.h>
#include<malloc.h>
typedef struct node //二叉排序树的结点类型
{
int key;
struct node *lchild,*rchild;
}BSTNode;
typedef BSTNode *BSTree;
void insertBST(BSTree *prt,int key)
{
BSTNode *f,*p=*prt;
while(p) // 判断数据插入的位置
{
if(p->key==key) // 树中已有此节点无需插入
return;
f=p;
p=(key<(p->key))?p->lchild:p->rchild;
}
p=(BSTNode *)malloc(sizeof(BSTNode)); //建立新的结点p->key=key;
p->lchild=p->rchild=NULL;
if(*prt==NULL)
*prt=p;
else if(key<f->key)
f->lchild=p;
else
f->rchild=p;
}
BSTree createBST(void)
{
BSTree T=NULL;
int key;
printf("请输入根节点\n"); //先建立一个根节点scanf("%d",&key);
while(key)
{
insertBST(&T,key);
printf("请输入一个数据以0结束:");
scanf("%d",&key);
}
return T;
}
void inorder(BSTree T) //中序遍历
{
if(T)
{
inorder(T->lchild);
printf("%3d ",T->key);
inorder(T->rchild);
}
}
void main()
{
BSTree T;
T=createBST();
printf("中序遍历结果:\n");
inorder(T);
}
3.实验结果
三.个人小结
通过这次实验,我对于各类查找的算法都有了很清晰的认识,在实验的过程中我深刻地体会到了作为一个合格的程序员,不仅仅要理解算法还要学会对其灵活运用,一定要多动手,在实践的过程中你会遇到各种意想不到的意外,当运用
自己的办法把问题都解决好了之后,自己的编程能力也有了一定的提高。