二分搜索实验报告.docx
《二分搜索实验报告.docx》由会员分享，可在线阅读，更多相关《二分搜索实验报告.docx（10页珍藏版）》请在冰豆网上搜索。
二分搜索实验报告
竭诚为您提供优质文档/双击可除
二分搜索实验报告
篇一：
算法设计与分析二分查找实验报告
课程设计说明书
设计题目：
二分查找程序的实现
专业：
班级：
设计人：
山东科技大学年月日
课程设计任务书
学院：
信息科学与工程学院专业：
班级：
姓名：
一、课程设计题目：
二分查找程序的实现二、课程设计主要参考资料
（1）计算机算法设计与分析（第三版）王晓东著
（2）三、课程设计应解决的主要问题
（1）二分查找程序的实现
（2）（3）四、课程设计相关附件（如：
图纸、软件等）：
（1）
（2）
五、任务发出日期：
20XX-11-21课程设计完成日期：
20XX-11-24
指导教师签字：
系主任签字：
指导教师对课程设计的评语
成绩：
指导教师签字：
年月日
二分查找程序的实现
一、设计目的
算法设计与分析是计算机科学与技术专业的软件方向的必修课。
同时，算法设计与分析既有较强的理论性，也有较强的实践性。
算法设计与分析的实验过程需要完成课程学习过程各种算法的设计和实现，以达到提高教学效果，增强学生实践动手能力的目标。
用分治法，设计解决二分查找程序的实现问题的一个简捷的算法。
通过解决二分查找程序的实现问题，初步学习分治策略。
二、设计要求
给定已按升序排好序的n个元素a[0:
n-1]，现要在这n个元素中找出一特定元素x。
实现二分搜索的递归程序并进行跟踪分析其执行过程。
用顺序搜索方法时，逐个比较a[0:
n-1]中的元素，直至找出元素x，或搜索遍整个数组后确定x不在其中。
这个方法没有很好的利用n个元素已排好序这个条件，因此在最坏情况下，顺序搜索方法需要o（n）次比较。
要求二分法的时间复杂度小于o（n）。
三、设计说明
（一）、需求分析
二分搜索方法充分利用了元素间的次序关系，采用分治策略，可在最坏情况下用o（logn）时间完成搜索任务。
该算法的流程图如下：
（二）、概要设计
二分查（:
二分搜索实验报告）找的基本思路是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x，算法终止；如果xa[n/2]，则只要在数组a的右半部分继续搜索x。
由于二分查找的数组不一定是一个整数数组，所以我采用了c++中的模板函数，将排序函数sort和二分查找函数binarysort写为了模板函数，这样不尽可以查找整数数组，也可以查找小数数组。
由于查找的数组的长度不固定，所以我用了c语言中的malloc和realloc函数，首先定义一个数组指针，用malloc函数该它分配空间，然后向数组中存数，当数组空间满时，在用realloc函数为数组再次分配空间。
由于在随机输入一组数时不知在什么位置停止，所以
篇二：
二分搜索实验报告
二分搜索
一．实验目的：
1.理解算法设计的基本步骤及各步的主要内容、基本要求；
2.加深对分治设计方法基本思想的理解，并利用其解决现实生活中的问题；
3.通过本次实验初步掌握将算法转化为计算机上机程序的方法。
二．实验内容：
1.编写实现算法：
给定n个元素，在这n个元素中找到值为key的元素。
2.将输入的数据存储到指定的文本文件中，而输出数据存放到另一个文本文件中，包括结果和具体的运行时间。
3.对实验结果进行分析。
三．实验操作：
1.二分搜索的思想：
首先，假设表中的元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
重复上述过程，知道找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
由于二分搜索是基于有序序列的一种搜索算法，故将输入的一组数据首先进行排序，考虑到输入数据可能有多个，采用快速排或者是合并排序，其中与冒泡做了对比。
冒泡排序算法：
voidsort（intList[],intlength）{
intchange;
for（inti=0;i for（intj=i+1;j if（List[i]>List[j]）{
change=List[i];
List[i]=List[j];
List[j]=change;
}
}
}
快速排序算法：
voidQsort（intList[],intlow,inthigh）{
if（low>=high）return;
intfirst=low;
intlast=high;
intkey=List[first];
while（first while（first while（first }
List[first]=key;
Qsort（List,low,first-1）;
Qsort（List,last+1,high）;}
二分查找算法：
intbinarysearch（intList[],intlow,inthigh,intkey）{
intmid=（low+high）/2;
if（high while（low if（List[mid]==key）returnmid+1;
else{
if（List[mid]>key）returnbinarysearch（List,low,mid-1,key）;elsereturnbinarysearch（List,mid+1,high,key）;
}
}
}
2.实验数据的输入：
本实验采用将数据输入与输出存储到文件中的方式，需要采用c++文件流操作，对于数据的输入，由于cin对数据的读取会忽略空格和换行操作，使用cin流输入来控制数据的输入。
对于输出操作，首先要从文件中读取数据，为了区别各数据，用逗号隔离，经过处理后将数据存入到另一文件之中。
由于输入需要大量的数据，可采用从“随机数.txt”中读取数据。
存入文件算法：
intinput（）{
ofstreamoutFile;
outFile.open（"e:
//程序设计/practice1/算法设计与分析文本文件夹D/number.txt",ios:
:
trunc）;
if（!
outFile.is_open（））cout cout charnumber;
intlength=0;
cin>>number;
while（number!
=e）{
length++;
outFile cin>>number;
}
outFile.close（）;
returnlength;
}
文件数据提取算法：
int*output（intlength）{
ifstreaminFile;
ofstreamoutFile;inFile.open（"e:
//程序设计/practice1/算法设计与分析/文本文件夹
D/number.txt"）;
outFile.open（"e:
//程序设计/practice1/算法设计与分析/文本文件
夹D/result2.txt",ios:
:
trunc）;
char*Array=newchar[length];
int*List=newint[length/2];
inti=0,j=0;
outFile while（!
inFile.eof（））{
inFile>>Array[i];
if（Array[i]!
=,0;
outFile j++;
}
i++;
}
sort（List,length/2）;
inFile.close（）;
outFile.close（）;
returnList;
}
3.程序运行时间测量:
为了得到二分搜索的时间，主要是排序的时间，调用time标准库，通过对起止时间记录，得到运行时间。
doublestart,end,Time;
start=clock（）;
调用程序；
end=clock（）;
Time=end-start;
四．实验数据分析：
当测试的数据较少时，如输入个数为20个时，两种排序时间都为0，即两种排序所消耗的时间差不多。
在数据小于2000个时，它们的耗费时间是代价相等的。
但当数据规模十分庞大时，快速排序的时间代价远远低于冒泡排序，例如当输入的数据为3000个时，快速排序的时间消耗是冒泡排序的1/3,由此可见一斑，并且当输入的数据完全逆序时，快速排序将和冒泡排序一样复杂。
最后将排序的时间与查找的时间相加，即为二分搜索的总时间，为
n（logn）+time.
五．实验感受：
在本次实验中，测试程序的运行时间时，需要用到大量的数据，仅仅输入100以内的数据对时间的测试不起作用，故用随机数生成并读取，解决了测试时间不明显的问题。
而对于输入的数据，其顺序也有一定影响性。
篇三：
冒泡排序和二分查找实验报告
冒泡排序和二分查找实验报告
一实验题目:
基于冒泡排序的二分查找
二实验要求:
2.1:
输出在顺序表中利用二分的方法查找关键字9的过程。
2.2：
实现冒泡排序的过程，并输出｛9，8，7，6，5，4，3，2，1，0｝的过程
三实验内容:
3.1动态查找表的抽象数据类型:
ADTDynamicsearchTable{
数据对象D：
D是具有相同特性的数据元素的集合。
各个数据元素均含有类型相同，可唯一标识数据元素的关键字
数据关系R：
数据元素同属一个集合。
基本操作p：
InitDsTable（
操作结果：
构造一个空的动态查找表DT。
DestroyDsTable（
初始条件：
动态查找表DT存在，key为和关键字类型相同的给定值。
操作结果：
若DT中存在其关键字等于key的数据元素，则函数值为该元素的值或在表中的位置，否则为“空”。
InsertDsTable（
初始条件：
动态查找表DT存在，e为待插入的数据元素。
操作结果：
若DT中不存在其关键字等于e.key的数据元素，则插入e到DT。
DeleteDsTable（
初始条件：
动态查找表DT存在，key为和关键字类型相同的给定值。
操作结果：
若DT中存在其关键字等于key的数据元素，则删除之。
TraverseDsTable（DT,visit（））;
初始条件：
动态查找表DT存在，visit是对结点操作的应用函数。
操作结果：
按某种次序对DT的每个结点调用函数visit（）一次且至多一次，一旦visit（）失败，则操作失败。
}ADTDynamicsearchTable
3.2存储结构的定义;
///二分查找
#definemaxn100
typedefstruct
{
intkey;
chardata[10];
}nodeType;
typedefnodeTypeseqList[maxn];
///冒泡排序
#definemaxn20
typedefstruct
{
intkey;
chardata[10];
}RecType;
3.3基本操作实现:
intbinsearch（seqListR,intn,intk）
{
intl=0,r=n-1,mid,count=0;
while（l {
mid=（l+r）/2;
printf（"第%d次比较：
在[%d,
R[%d]:
%d\n",++count,l,r,mid,R[mid].key）;
if（R[mid].key==k）
{
returnmid;
}%d]中比较元素
elseif（R[mid].key>k）
{
r=mid-1;
}
else
{
l=mid+1;
}
}
return-1;
}
voidbubblesort（RecTypeR[],intn）
{
inti,j,k;
RecTypetemp;
for（i=0;i {
for（j=n-1;j>i;--j）
{
if（R[j].key {
temp=R[j];
R[j]=R[j-1];
R[j-1]=temp;
}
}
printf（"i=%d，冒出的最小关键字：
%d，结果为：
",i,R[i].key）;
for（k=0;k printf（"%2d",R[k].key）;
printf（"\n"）;
}
}
3.4解题思路：
二分查找：
因为原本便是顺序表，是递增序列，所以在一个区间中，我们只要每次判断中间节点和被查找的关键字的大小关系，就可以判断被查找的节点在那一段区间了，然后再进行二分即可。
冒泡排序：
通过一次一次的交换，把无序序列中关键字最小的节点的值交换到前面即可。
3.5解题过程：
实验源代码如下：
3.5.1二分查找
#include
#definemaxn100
typedefstruct
{
intkey;
chardata[10];
}nodeType;
typedefnodeTypeseqList[maxn];
intbinsearch（seqListR,intn,intk）
{
intl=0,r=n-1,mid,count=0;
while（l {
mid=（l+r）/2;
printf（"第%d次比较：
在[%d,
R[%d]:
%d\n",++count,l,r,mid,R[mid].key）;
if（R[mid].key==k）
{
returnmid;
}
elseif（R[mid].key>k）
{
r=mid-1;
}
else
{
l=mid+1;
}
}
return-1;
}
intmain（）%d]中比较元素
{
seqListR;
intk=9;
inta[]={1,2,3,4,5,6,7,8,9,10},i,n=10;for（i=0;i {
R[i].key=a[i];
}
printf（"关键字序列：
"）;
for（i=0;i printf（"%d",R[i].key）;
printf（"\n"）;
printf（"查找%d的比较过程如下：
\n",k）;if（（i=binsearch（R,n,k））!
=-1）
printf（"元素%d的位置是：
%d\n",k,i）;else
printf（"元素%d不在表中\n",k）;return0;
}
3.5.2冒泡排序
#include
#definemaxn20
typedefstruct
{
intkey;
chardata[10];
}RecType;
voidbubblesort（RecTypeR[],intn）
{
inti,j,k;
RecTypetemp;
for（i=0;i {
for（j=n-1;j>i;--j）
{
if（R[j].key
升级会员 