C语言程序—顺序查找和折半查找
折半查找程序
先看看这个，下面有例子折半查找：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。
因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
算法要求算法复杂度下面提供一段二分查找实现的伪代码:BinarySearch(max,min,des)mid-<(max+min)/2while(min<=max)mid=(min+max)/2if mid=des thenreturn midelseif mid >des thenmax=mid-1elsemin=mid+1return max折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。
它的基本思想是，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。
如果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。
如果x>a[n/2]，则我们只要在数组a的右半部继续搜索x。
二分查找法一般都存在一个临界值的BUG，即查找不到最后一个或第一个值。
可以在比较到最后两个数时，再次判断到底是哪个值和查找的值相等。
C语言代码int BinSearch(SeqList * R，int n , KeyType K ){ //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1int low=0，high=n-1，mid；//置当前查找区间上、下界的初值if(R[low].key==K){return low ;}if(R[high].key==k)return high;while(low<=high){ //当前查找区间R[low..high]非空mid=low+((high-low)/2)；//使用(low + high) / 2 会有整数溢出的问题（问题会出现在当low + high的结果大于表达式结果类型所能表示的最大值时，这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题if(R[mid].key==K){return mid；//查找成功返回}if(R[mid].key>K)high=mid-1; //继续在R[low..mid-1]中查找elselow=mid+1；//继续在R[mid+1..high]中查找}if(low>high)return -1；//当low>high时表示查找区间为空，查找失败} //BinSeareh折半查找程序举例程序要求：1.在main函数中定义一个20个元素的int数组，完成初始化和显示操作。
c语言查找算法
c语言查找算法
C语言是一种广泛使用的编程语言，它具有高效、简单、易学等特点，因此在各个领域都有广泛的应用。
在C语言中，查找算法是一种非常
重要的算法，它可以帮助我们在大量数据中快速查找到我们需要的数据。
下面我们将详细介绍C语言中的查找算法。
一、顺序查找算法
顺序查找算法是一种最简单的查找算法，它的基本思想是从数据的第
一个元素开始逐个比较，直到找到目标元素或者遍历完整个数据。
顺
序查找算法的时间复杂度为O(n)，其中n为数据的长度。
二、二分查找算法
二分查找算法也称为折半查找算法，它的基本思想是将数据分成两部分，然后判断目标元素在哪一部分中，再在该部分中继续进行查找，
直到找到目标元素或者确定目标元素不存在。
二分查找算法的时间复
杂度为O(logn)，其中n为数据的长度。
三、哈希查找算法
哈希查找算法是一种利用哈希表进行查找的算法，它的基本思想是将数据通过哈希函数映射到哈希表中，然后在哈希表中查找目标元素。
哈希查找算法的时间复杂度为O(1)，但是它需要额外的空间来存储哈希表。
四、树查找算法
树查找算法是一种利用树结构进行查找的算法，它的基本思想是将数据构建成一棵树，然后在树中查找目标元素。
树查找算法的时间复杂度为O(logn)，但是它需要额外的空间来存储树结构。
总结：
C语言中的查找算法有顺序查找算法、二分查找算法、哈希查找算法和树查找算法。
不同的算法适用于不同的场景，我们可以根据实际情况选择合适的算法来进行查找。
在实际应用中，我们还可以将不同的算法进行组合，以达到更高效的查找效果。
利用数组进行数据查找_折半查找法_C语言程序
↑low↑mid↑high
第三步：上一步中，所找数80比mid指示的100小，可知新的查找区间为[56 80]，low不变，mid与high的值作相应修改。mid指示的数为56，还要继续查找。
-12 0 6 16 23 [ 56 80 ] 100 110 115
scanf("%d",&n);
while(low<=high)
{mid=(low+high)/2;
if (n= =a[mid]) {found=1;break;}/*找到，结束循环*/
else if (n>a[mid]) low=mid+1;
else high=mid-1;
}
if (found==1) printf("The index of %d is %d",n,mid);
例7.10假设在数组a中的数据是按由小到大顺序排列的：
-12 0 6 16 23 56 80 100 110 115，从键盘上输入一个数，判定该数是否在数组中，若在，输出所在序号；若不在，输出相应信息。
查找过程如下：
第一步：设low、mid和high三个变量，分别指示数列中的起始元素、中间元素与最后一个元素位置,其初始值为low=0,high=9,mid=4，判断mid指示的数是否为所求，mid指示的数是23，不是要找的80，须继续进行查找。
选定这批数中居中间位置的一个数与所查数比较看是否为所找之数若不是利用数据的有序性可以决定所找的数是在选定数之前还是在之后从而很快可以将查找范围缩小一半
适应情况：在一批有序数据中查找某数
基本思想：选定这批数中居中间位置的一个数与所查数比较，看是否为所找之数，若不是，利用数据的有序性，可以决定所找的数是在选定数之前还是在之后，从而很快可以将查找范围缩小一半。以同样的方法在选定的区域中进行查找，每次都会将查找范围缩小一半，从而较快地找到目的数
数据结构——查找,顺序查找,折半查找
实验五查找的应用一、实验目的：1、掌握各种查找方法及适用场合，并能在解决实际问题时灵活应用。
2、增强上机编程调试能力。
二、问题描述1.分别利用顺序查找和折半查找方法完成查找。
有序表（3,4,5,7,24,30,42,54,63,72,87,95）输入示例：请输入查找元素：52输出示例：顺序查找：第一次比较元素95第二次比较元素87 ……..查找成功，i=**/查找失败折半查找：第一次比较元素30第二次比较元素63 …..2.利用序列（12,7,17,11,16,2,13,9,21,4）建立二叉排序树，并完成指定元素的查询。
输入输出示例同题1的要求。
三、数据结构设计（选用的数据逻辑结构和存储结构实现形式说明）（1）逻辑结构设计顺序查找和折半查找采用线性表的结构，二叉排序树的查找则是建立一棵二叉树，采用的非线性逻辑结构。
（2）存储结构设计采用顺序存储的结构，开辟一块空间用于存放元素。
（3）存储结构形式说明分别建立查找关键字，顺序表数据和二叉树数据的结构体进行存储数据四、算法设计（1）算法列表（说明各个函数的名称，作用，完成什么操作）序号 名称 函数表示符 操作说明1 顺序查找 Search_Seq 在顺序表中顺序查找关键字的数据元素2 折半查找 Search_Bin 在顺序表中折半查找关键字的数据元素3 初始化 Init 对顺序表进行初始化，并输入元素4 树初始化 CreateBST 创建一棵二叉排序树5 插入 InsertBST 将输入元素插入到二叉排序树中6 查找 SearchBST在根指针所指二叉排序树中递归查找关键字数据元素 （2）各函数间调用关系（画出函数之间调用关系）typedef struct { ElemType *R; int length;}SSTable;typedef struct BSTNode{Elem data; //结点数据域 BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree; typedef struct Elem{ int key; }Elem;typedef struct {int key;//关键字域}ElemType;（3）算法描述int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。
具有12个关键字的有序表,折半查找的平均查找长度
具有12个关键字的有序表,折半查找的平均查
找长度
折半查找是一种在有序序列中查找某个给定值的方法，它是一种加速搜索的算法，并且有着高效、可靠的特点，在每次搜索次数减半的情况下，无论序列的长度多大，其查找代价是固定的，能大大减少存储器和 CPU 占用，节省时间和空间。
折半查找时，先取出中间位置记录，将查找值和中间位置记录进行比较，子表长度缩小，重复上述查找操作，直到找到等于查找值的记录，或子表不存在为止。
如果有12个关键字的有序表，用折半查找方法来查找，那么平均查找长度(ASL)是[log2(n)]+1=4。
从0开始计数，折半查找找到元素最多需要3步：第一步，查找中间位置的元素；第二步，比较查找元素与中间位置的元素的大小，如果查找元素小于中间位
置的元素，就在中间位置的左半边的子序列中继续查找；如果查找元素大于中间位置的元素，就在中间位置的右半边的子序列中继续查找；第三步，不断进行折半查找，直到找到查找元素，或者查找范围为空，则查找失败，结束。
总的来说，折半查找是一种非常有效的搜索算法
它可以在有序表中大大加快搜索速度，在12个关键字有序表中，折半查找的平均查找长度是4，在节省时间和空间的同时，能够很好地用于搜索、匹配等需要的操作中。
C语言及实验作业参考做法
C语言及实验作业参考做法分支程序设计笔头作业：1．输入4个整数，按从小到大的顺序输出2．根据月份判断季节。
输入月份，输出春/夏/秋/冬。
要求用switch语言实现3．学生学习两门课：必修课成绩为course1，选修课成绩为course2，若两门都及格，打印pass，必修课不及格，打印fail4．从键盘输入一个年份,判该年是否是闰年,是闰年就输出yes,否则输出no 5．从键盘输入一个字符,判断该字符是数字字符、大写字母、小写字母、空格还是其他字符。
6．商店卖西瓜，10斤以上每斤0.8元, 8斤以上每斤0.6元, 6斤以上每斤0.4元,4斤以上每斤0.3元, 4斤以下每斤0.15元,输入西瓜重量和所付的钱数,输出应付的货款和应找的钱数循环程序设计书面作业：1．从键盘上输入10个整数,计算这些整数的和2．水仙花数。
一个3位数,若其各位数字之和等于它本身,这个数就称为水仙花数.输出所有的水仙花数。
(如153)#include<stdio.h>int main()//方法一{ int num,bai,shi,ge;for(num=100; num<1000; num++){bai=num/100;shi=num/10%10;ge=num%10;if(num==bai*bai*bai+shi*shi*shi+ge*ge*ge)printf("%d\n",num);}return 0;}//方法二int main(){int i,j,k;for(i=1; i<10; i++)for(j=0; j<10; j++)for(k=0; k<10; k++)if(i*100+j*10+k==i*i*i+j*j*j+k*k*k)printf("%d\n",100*i+j*10+k);return 0;}3．计算分数序列2/1，3/2，5/3，8/5，13/8，21/13，.....前20项之和。
【C++】顺序查找与折半查找(附带解说)
else low=mid+1; //如果所比较的元素比查找的大，则从元素值比较高的一方中查找
}
return -1; //未找到则输出-1
1、顺序查找
#include <iostream.h>
#define M 10
int search(int a[],int x,int n) //定义【查找函数】 定义形参为实型数组a[]（被查找的数组） ，实型数x（需要查找的数） ，实型数n（数组内元素的个数）
cin>>x;
p=search(array,x,M); //调用【查找函数】，同时接受返回值
cout<< "原始数组：" <<endl;
for(i=0;i<M;i++)
cout<< a[i] <<"\t";
if(p>=0) cout<< "查找成功!该数的下标为：" << p <<endl;
p=bi_search(array,x,M);
cout<< "原始数组为：" <<endl;
for(i=0;i<M;i++)
cout<< array[i] <<"\t";
if(p>=0) cout<< "查找成功!数组元素下标为：" << p <<endl;
数据结构实验---折半查找实验报告
深圳大学实验报告课程名称：数据结构实验项目名称：查找排序之折半查找学院：信息工程学院专业：电子信息工程指导教师：报告人：学号：2009100000 班级：电子1班实验时间：2011年12月2日实验报告提交时间：2011年12月13日教务处制//调用函数Search_Bin，并将函数返回结果放在i中i = Search_Bin(Data, Dnum, skey);printf("----------------------------------------\n");if(i==-1) //若Search_Bin返回值为-1则显示查找失败printf("查找失败!\n");else //不然则执行下面语句{printf("查找成功!\n");printf("查找的数据位置在(%d)\n",i);}printf("查找次数(%d)",icount);printf("\n");return 0;}四、实验结论：实结果图：情况一、能够在待查数组中查找到待查元素情况二、不能够在待查数组中查找到待查元素数据分析基于上面程序运行图可以很明显得知整个算法的实现过程，针对第一个图：1、首先建立一个数组存放待查元素2、针对定值key进行折半查找，第一个图可以得到key=113、mid=（low+high）/2 =（0+5）/2 =2.得到的是ST[2]=33,查找了一次4、判断ST[2]=33大于key=11，即执行high=mid-1=15、mid=（low+high）/2 =（0+1）/2 =0.得到的是ST[0]=11=key，查找成功，查找了两次6、返回待查元素所在位置7、同理。
若查找不成功则返回查找失败五、实验体会：本次实验很简单，只要掌握折半查找算法的原理，那么剩下的就是花时间编写代码和调试程序。
C语言程序设计的常用算法
3、合并法排序（将两个有序数组 A、B 合并成另一个有序的数组 C，升序） 基本思想： 1）先在 A、B 数组中各取第一个元素进行比较，将小的元素放入 C 数组；
2）取小的元素所在数组的下一个元素与另一数组中上次比较后较大的元素比较，重复上述 比较过程，直到某个数组被先排完； 3）将另一个数组剩余元素抄入 C 数组，合并排序完成。 程序代码如下： #include<stdio.h>
/////////////////////////////////////////////////////////////////////////////// void main() {
int x,i; int prime(int m); printf("please input a even number(>=6):"); scanf("%d",&x); if (x<6||x%2!=0)
int a[10],p,x,i; printf("please input the array:"); for(i=0;i<10;i++)
scanf("%d",&a[i]); printf("please input the number you want find:"); scanf("%d",&x); p=0; while(x!=a[p]&&p<10)
printf("%2d",c[i]); printf("\n"); }
数据结构(C语言版清华大学出版社)-章课后部分答案
第八章选择题1. C2.A3.B4.C5.D6.B7.B8.A9.D 10.D 11.C 12.C填空题1.n、n+12. 43.8.25( 折半查找所在块 )4.左子树、右子树5.266.顺序、(n+1)/2、O(log2n)7.m-1、[m/2]-18.直接定址应用题1.进行折半查找时，判定树是唯一的，折半查找过程是走了一条从根节点到末端节点的路径，所以其最大查找长度为判定树深度[log2n]+1.其平均查找长度约为[log2n+1]-1.在二叉排序树上查找时，其最大查找长度也是与二叉树的深度相关，但是含有n个节点的二叉排序树不是唯一的，当对n个元素的有序序列构造一棵二叉排序树时，得到的二叉排序树的深度也为n，在该二叉树上查找就演变成顺序查找，此时的最大查找长度为n；在随机情况下二叉排序树的平均查找长度为1+4log2n。
因此就查找效率而言，二分查找的效率优于二叉排序树查找，但是二叉排序树便于插入和删除，在该方面性能更优。
3. 评价哈希函数优劣的因素有：能否将关键字均匀的映射到哈希表中，有无好的处理冲突的方法，哈希函数的计算是否简单等。
冲突的概念：若两个不同的关键字Ki和Kj，其对应的哈希地址Hash(Ki) =Hash(Kj)，则称为地址冲突，称Ki和K,j为同义词。
（1）开放定址法（2）重哈希法（3）链接地址法4.（1）构造的二叉排序树，如图（2）中序遍历结果如下：10 12 15 20 24 28 30 35 46 50 55 68（4）平均查找长度如下：ASLsucc = （1x1+2x2+3x3+4x3+5x3）/12 = 41/128.哈希地址如下：H(35) = 35%11 = 2H(67) = 67%11 = 1H(42) = 42%11 = 9H(21) = 21%11 = 10H(29) = 29%11 = 7H(86) = 86%11 = 9H(95) = 95%11 = 7H(47) = 47%11 = 3H(50) = 50%11 = 6H(36) = 36%11 = 3H(91) = 91%11 = 3第九章选择题1. D2.C3.B4.D5.C6.B7.A8.A9.D 10.D填空题1.插入排序、交换排序、选择排序、归并排序2.移动（或者交换）3.归并排序、快速排序、堆排序4.保存当前要插入的记录，可以省去在查找插入位置时的对是否出界的判断5.O(n)、O(log2n)6.直接插入排序或者改进了的冒泡排序、快速排序7.Log2n、n8.完全二叉树、n/29.1510.{12 38 25 35 50 74 63 90}应用题11.（1）Shell排序(步长为5 3 1)每趟的排序结果初始序列为100 87 52 61 27 170 37 45 61 118 14 88 32步长为5的排序14 37 32 61 27 100 87 45 61 118 170 88 52步长为3的排序结果14 27 32 52 37 61 61 45 88 87 170 100 118步长为1的排序结果14 27 32 37 45 52 61 61 87 88 100 118最后结果14 27 32 37 45 52 61 61 87 88 100 118 170（2）快速排序每趟的排序结果如图初始序列100 87 52 61 27 170 37 45 61 118 14 88 32第一趟排序[32 87 52 61 27 88 37 45 61 14]100[118 170]第二趟排序[14 27]32[61 52 88 37 45 61 87]100 118[170]第三趟排序14[27]32[45 52 37]61[88 61 87]100 118[170]第四趟排序14[27]32[37]45[52]61[87 61]88 100 118[170]第五趟排序14[27]32[37]45[52]61[87 61]88 100 118[170]最后结果14[27]32[37]45[52]61[61]87 88 100 118[170]（3）二路归并排序每趟的排序结果初始序列[100][87][52][61][27][170][37][45][61][118][14][88][32]第一趟归并[87 100][52 61][27 170][37 45][61 118][14 88][32]第二趟归并[52 61 87 100][27 37 45 170][14 61 88 118][32]第三趟归并排序[27 37 45 52 61 87 100 170][14 32 61 88 118]第四趟归并排序[14 27 32 37 45 52 61 61 87 88 100 118 170]最后结果14 27 32 37 45 52 61 61 87 88 100 118 17012.采用快速排序时，第一趟排序过程中的数据移动如图：算法设计题1.分析：为讨论方便，待排序记录的定义为（后面各算法都采用此定义）：#define MAXSIZE 100 /* 顺序表的最大长度，假定顺序表的长度为100 */ typedef int KeyType; /* 假定关键字类型为整数类型 */typedef struct {KeyType key; /* 关键字项 */OtherType other; /* 其他项 */}DataType; /* 数据元素类型 */typedef struct {DataType R[MAXSIZE+1]; /* R[0]闲置或者充当哨站 */int length; /* 顺序表长度 */}sqList; /* 顺序表类型 */设n个整数存储在R[1..n]中，因为前n-2个元素有序，若采用直接插入算法，共要比较和移动n-2次，如果最后两个元素做一个批处理，那么比较次数和移动次数将大大减小。
C语言实现顺序表的顺序查找和折半查找
C语⾔实现顺序表的顺序查找和折半查找本⽂实例为⼤家分享了C语⾔实现顺序表的顺序查找和折半查找的具体代码，供⼤家参考，具体内容如下顺序查找：#include <iostream>using namespace std;int SeqSearch(int r[],int n,int k){r[0]=k;//下标0⽤作哨兵存放要查询的数int i=n;while(r[i]!=k)//不⽤判断下标i是否越界{i--;}return i;}int main(){int n;cout<<"请输⼊数组元素个数："<<endl;cin>>n;int a[n+1];cout<<"请输⼊数组元素："<<endl;for(int i=1;i<=n;i++){cin>>a[i];}int k;cout<<"请输⼊要查询的数："<<endl;cin>>k;for(int i=1;i<=n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"该数在数组中的位置为：";cout<<SeqSearch(a,n,k);return 0;}折半查找：#include<iostream>using namespace std;int BinSearch1(int r[],int n,int k)//⾮递归{int low=1,high=n;//设置查找区间while(low<=high)//如果区间存在{int mid=(low+high)/2;if(k<r[mid])high=mid-1;//查找在左半区进⾏，回到while那⼀步else if(k>r[mid])low=mid+1;else return mid;}return 0;//如果区间不存在，则返回0，查找失败}int BinSearch2(int r[],int low,int high,int k)//递归{int mid=(low+high)/2;if(low>high) return 0;else{if(k<r[mid])BinSearch2(r,low,mid-1,k);else if(k>r[mid])BinSearch2(r,mid+1,high,k);else return mid;}}int main(){int n;cout<<"请输⼊数组元素个数：";cout<<endl;cin>>n;int a[n+1];cout<<"请输⼊数组元素：";cout<<endl;for(int i=1;i<=n;i++){cin>>a[i];}cout<<"请输⼊要查找的数：";cout<<endl;int k;cin>>k;cout<<"该数在数组中的位置是："<<endl;cout<<BinSearch1(a,n,k);cout<<endl;cout<<BinSearch2(a,1,n,k);}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
C语言算法排序与查找
10
10 5 j
10> 5?
5
5 10 j
22
22 j
10> 22?
34
34
45
45
89
89
排i=3位置
22> 34?
5
10
22
34
45
89
• 冒泡法的核心：小数上浮，大数下沉。 • 冒泡法第四轮：使第四大的数放在倒数第四个位置上
i i=3 0 1 2 3 4 5
5
5 j
5> 10?
10
10 j
22
22
34
34
45
45
89
89
排i=2位置
10> 22?
5
10
22
34
45
89
• 冒泡法的核心：小数上浮，大数下沉。 • 冒泡法第五轮：使第五大的数放在倒数第五个位置上
i i=4 0 1 2 3 4 5
5
5 j
5> 10?
10
10
22
22
34
34
45
45
89
89
排i=1位置
5
10
22
34
45
89
中心段程序为 for (i = 0; i < 10 - 1; i++) { for ( j = 0; j< 10 - i - 1; j++) { if(arr[j] > arr[j+1]) { temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } }
排序
《折半查找法》课件
在数据库、搜索引擎、物流配送 等领域，快速准确的查找是实现 高效服务的关键。
折半查找法的概念
• 定义：折半查找法，又称二分查找法，是一种在有序数组中查 找某一特定元素的搜索算法。搜索过程从数组的中间元素开始 ，如果中间元素正好是要查找的元素，则搜索过程结束；如果 某一特定元素大于或者小于中间元素，则在数组大于或小于中 间元素的那一半中查找，而且跟开始一样从中间元素开始比较 。如果在某一步骤数组为空，则代表找不到。这种搜索算法每 一次比较都使搜索范围缩小一半。
感谢观看
与线性查找法相比，折半查找 法在数据量大的情况下具有明 显优势。
需要快速查找的场景
在某些对时间要求较高的场景中 ，如实时交易系统、在线游戏等
，需要快速查找数据。
折半查找法能够在较短时间内找 到目标数据，满足快速查找的需
求。
与其他查找算法相比，折半查找 法具有较高的查找速度。
二分搜索的应用场景
二分搜索是折半查找法的另一种表述方式，适用于有序数组的查找。
线性二分查找的变种
在有序数组中，从中间元素开始，如果中间元素正好是目标值，则搜索过程结束；如果目标值大于或 小于中间元素，则在数组大于或小于中间元素的那一半中查找，但这一次从那一半的起始位置开始比 较。
多重二分查找
多重二分查找是指在一次二分查找过程中，对多个有序数组 进行查找的方法。通过将多个有序数组按照某种规则进行组 合，可以大大提高查找效率。
在需要频繁进行查找操作的场景中，如搜索引擎、数据分析等，二分搜索能够提高 查找效率。
二分搜索适用于任何有序数据集，只要能够确定数据集的左边界和右边界即可。
05
折半查找法的优化与改进
二分查找的变种
线性二分查找
数据结构50：二分查找法（折半查找法）
数据结构50：⼆分查找法（折半查找法）折半查找，也称⼆分查找，在某些情况下相⽐于顺序查找，使⽤折半查找算法的效率更⾼。
但是该算法的使⽤的前提是静态查找表中的数据必须是有序的。
例如，在{5,21,13,19,37,75,56,64,88 ,80,92}这个查找表使⽤折半查找算法查找数据之前，需要⾸先对该表中的数据按照所查的关键字进⾏排序：{5,13,19,21,37,56,64,75,80,88,92}。
在折半查找之前对查找表按照所查的关键字进⾏排序的意思是：若查找表中存储的数据元素含有多个关键字时，使⽤哪种关键字做折半查找，就需要提前以该关键字对所有数据进⾏排序。
折半查找算法对静态查找表{5,13,19,21,37,56,64,75,80,88,92}采⽤折半查找算法查找关键字为 21 的过程为：图 1 折半查找的过程（a）如上图 1 所⽰，指针 low 和 high 分别指向查找表的第⼀个关键字和最后⼀个关键字，指针 mid 指向处于 low 和 high 指针中间位置的关键字。
在查找的过程中每次都同 mid 指向的关键字进⾏⽐较，由于整个表中的数据是有序的，因此在⽐较之后就可以知道要查找的关键字的⼤致位置。
例如在查找关键字 21 时，⾸先同 56 作⽐较，由于21 < 56，⽽且这个查找表是按照升序进⾏排序的，所以可以判定如果静态查找表中有 21这个关键字，就⼀定存在于 low 和 mid 指向的区域中间。
因此，再次遍历时需要更新 high 指针和 mid 指针的位置，令 high 指针移动到 mid 指针的左侧⼀个位置上，同时令 mid 重新指向 low 指针和 high 指针的中间位置。
如图 2 所⽰：图 2 折半查找的过程（b）同样，⽤ 21 同 mid 指针指向的 19 作⽐较，19 < 21，所以可以判定 21 如果存在，肯定处于 mid 和 high 指向的区域中。
所以令 low 指向 mid 右侧⼀个位置上，同时更新 mid 的位置。
数据结构(C语言版CHAP8(1)
设查找每一个记录的概率相同,即均为1/10, 平均查找长度ASL =在查找过程中与给定值比较的关键字个数的数学期望 值∑ PiCi=(1+2×2+4×3+3×4)/10
结束
第 19 页
9.2 静态查找表
说明: 1) 折半查找法效率比顺序查找高;平均查找长度ASLbs=log2(n+1)-1 2) 要求表中的记录按关键字有序; 3) 表中的记录要用顺序结构存储; 例 在有1000个记录的查找表查找,顺序查找法平均要比较500次,折半 查找法平均要比较9次,可见折半查找法效率比顺序查找高.
结束
第 16 页
9.2 静态查找表
例1
), Key=24的记录 L2=( 3,12,24,37,45,53,61,78,90,100 ),查找 Key=24的记录 1 3 2 3 4 5 6 7 8 9 10 12 24 37 45 53 61 78 90 100 low mid high
24 < 45
结束
第 18 页
9.2 静态查找表
二分查找法查找过程可用判定树描述 1 2 树描述 Key=24的查找路 径为5,2,3,所需 的比较次数为3 5 2 1 3 4 6 7 8 9 10 查找第2,8个记录需 的比较次数均为2 查找第5个记录需 的比较次数为1 3 4 5 6 7 8 9 10 ), 例 L2=( 3,12,24,37,45,53,61,78,90,100 ),查找过程可用如下判定
结束
第 10 页
9.1
概 述
约定:假设 1) 本章查找是关于主关键字查找; 2)假设本章涉及的关键字为整型类型; 3)为使查找的图示简洁,对于查找表中的每一记录,只写出其关键字; 关键字类型定义为 typedef int KeyType; 记录类型定义为: stypedef struct{ KeyType key; //关键字域 … //其它域 }ElemType;
查找实验报告
查找实验报告第一篇：查找实验报告实验六查找实验目的：掌握几种查找的思想及算法问题分析：（一）顺序查找 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.算法分析①查找时每经过一次比较，查找范围就缩小一半，该过程可用一棵二叉树表示：◆根结点就是第一次进行比较的中间位置的记录；◆ 排在中间位置前面的作为左子树的结点；◆ 排在中间位置后面的作为右子树的结点；对各子树来说都是相同的。
C语言程序设计100例之(21)：折半查找
C语言程序设计100例之（21）：折半查找例21 折半查找问题描述顺序查找是一种最简单和最基本的检索方法。
其基本思想是：从检索表的一端（如表中第一个记录或最后一个记录）开始，逐个进行记录的关键字和给定值的比较。
若某个记录的关键字和给定值比较相等，则查找成功；否则，若直至检索表的另一端（如最后一个记录或第一个记录），其关键字和给定值比较都不等，则表明表中没有待查记录，查找不成功。
顺序查找可以写成一个简单的一重循环，循环中依次将检索表（不妨设为数组a）中的元素与给定值比较，若相等，用break退出循环。
算法描述为：for (i=0; i< n;i++)if (a[i]==x) break;这样，循环结束后，若循环控制变量i小于数组元素个数n，则查找成功；否则，查找失败。
顺序查找实现简单，但效率不高。
当待查找序列有序时，即各检索表中元素的次序是按其记录的关键字值的大小顺序存储的。
此时采用折半查找会大幅提高查找效率。
折半查找的基本思想是先确定待查数据的范围（区间），然后逐步缩小范围直到找到或找不到该记录为止。
具体做法是：先取数组中间位置的数据元素与给定值比较。
若相等，则查找成功；否则，若给定值比该数据元素的值小（或大），则给定值必在数组的前半部分（或后半部分），然后在新的查找范围内进行同样的查找。
如此反复进行，直到找到数组元素值与给定值相等的元素或确定数组中没有待查找的数据为止。
因此，折半查找每查找一次，或成功，或使查找数组中元素的个数减少一半，当查找数组中不再有数据元素时，查找失败。
输入一个整数，在给定的有序数组中查找该整数是否存在，若存在，给出其数组的下标；若不存在，输出查找不成功信息。
输入格式第一行是一个正整数N (1 ≤N ≤100000)，代表数组中元素的个数。
第二行有N个整数，这N个整数从小到大排列好了。
第三行是一个整数M，代表待查找元素的个数。
接下来的M行，每行有一个整数x，表示每个待查找的元素。
C语言程序顺序查找和折半查找
#include <stdio.h>#define MAXLEN 50typedef struct {int key;char data;}datatype;int getsort(datatype x[] );int seqsearch(datatype x[],int key,int n);int binsearch(datatype x[],int key,int n );void insertsort(datatype x[],int n);void print(datatype x[],int n);void main(){ int sel,n,s,key,i; /*sel 输入选择，n 记录长度，s 查找方法的选择，key 查找关键字给定值，i 目标记录的下标*/ datatype x[MAXLEN];printf("请输入你的选择：1---开始其他选择为退出\nyour choice =");scanf("%d",&sel);while(sel==1){ printf("\n输入关键字序列，以－1结束输入：");n=getsort(x );printf("请输入选择的查找方法：1---顺序查找2---折半查找3-退出查找\nyour choice =");scanf("%d",&s);while(s!=3){ printf("请输入查找关键字给定值key＝");scanf("%d",&key);if(s==1){ printf("\n原关键字序列为：");print(x,n);i=seqsearch(x,key,n);if(i==-1)printf("\n没有给定值记录！\n");elseprintf("\n查找的结果为表中的第%d 条记录!\n",i+1); }else if(s==2){ i= binsearch(x,key,n );if(i==-1)printf("\n没有给定值记录！\n");elseprintf("\n查找的结果为表中的第%d 条记录!\n",i+1); }elseprintf("选择错误！\n");printf("请输入选择的查找方法：1---顺序查找2---折半查找3-退出查找\nyour choice =");scanf("%d",&s); }printf("请输入你的选择：1---开始其他选择为退出\nyour choice =");scanf("%d",&sel); } }/*输入记录的关键字*/int getsort(datatype x[] ){ int i=0;scanf("%d",&x[i].key);while(x[i].key!=-1){ i++;scanf("%d",&x[i].key); }return i; }/*顺序查找*/int seqsearch(datatype x[],int key,int n){ int i;for(i=0;i<n;i++){ if(key==x[i].key)return i; }return -1; }/*折半查找*/int binsearch(datatype x[],int key, int n){ int low,mid,hig; /*定义位置指示器*/ datatype y[MAXLEN];low=0;hig=n-1;for(int i=0;i<n;i++)y[i]=x[i];insertsort(y,n); /*排序*/printf("\n排序后关键字序列为：");print(y,n);while(low<=hig) /*查找*/{ mid=(low+hig)/2;if(key ==y[mid].key)return mid;else if(key >y[mid].key)low=mid+1;elsehig=mid-1; }return -1; }/*直接插入排序*/void insertsort(datatype x[],int n){ int i,j;datatype temp; /*中间变量*/ for(i=1;i<n;i++){ temp=x[i];j=i-1;while(j>-1 && temp.key<x[j].key){ x[j+1]=x[j];j--; }x[j+1]=temp; } }/*显示输出*/void print(datatype x[],int n){ int i;for(i=0;i<n;i++)printf("%d\t",x[i]);printf("\n"); }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include <stdio.h>
#define MAXLEN 50
typedef struct {
int key;
char data;
}datatype;
int getsort(datatype x[] );
int seqsearch(datatype x[],int key,int n);
int binsearch(datatype x[],int key,int n );
void insertsort(datatype x[],int n);
void print(datatype x[],int n);
void main()
{ int sel,n,s,key,i; /*sel 输入选择，n 记录长度，s 查找方法的选择，key 查找关键字给定值，i 目标记录的下标*/
datatype x[MAXLEN];
printf("请输入你的选择：1---开始其他选择为退出\nyour choice =");
scanf("%d",&sel);
while(sel==1)
{ printf("\n输入关键字序列，以－1结束输入：");
n=getsort(x );
printf("请输入选择的查找方法：1---顺序查找2---折半查找3-退出查找\nyour choice =");
scanf("%d",&s);
while(s!=3)
{ printf("请输入查找关键字给定值key＝");
scanf("%d",&key);
if(s==1)
{ printf("\n原关键字序列为：");
print(x,n);
i=seqsearch(x,key,n);
if(i==-1)
printf("\n没有给定值记录！\n");
else
printf("\n查找的结果为表中的第%d 条记录!\n",i+1); } else if(s==2)
{ i= binsearch(x,key,n );
if(i==-1)
printf("\n没有给定值记录！\n");
else
printf("\n查找的结果为表中的第%d 条记录!\n",i+1); } else
printf("选择错误！\n");
printf("请输入选择的查找方法：1---顺序查找2---折半查找3-退出查找\nyour choice =");
scanf("%d",&s); }
printf("请输入你的选择：1---开始其他选择为退出\nyour choice =");
scanf("%d",&sel); } }
/*输入记录的关键字*/
int getsort(datatype x[] )
{ int i=0;
scanf("%d",&x[i].key);
while(x[i].key!=-1)
{ i++;
scanf("%d",&x[i].key); }
return i; }
/*顺序查找*/
int seqsearch(datatype x[],int key,int n)
{ int i;
for(i=0;i<n;i++)
{ if(key==x[i].key)
return i; }
return -1; }
/*折半查找*/
int binsearch(datatype x[],int key, int n)
{ int low,mid,hig; /*定义位置指示器*/
datatype y[MAXLEN];
low=0;
hig=n-1;
for(int i=0;i<n;i++)
y[i]=x[i];
insertsort(y,n); /*排序*/
printf("\n排序后关键字序列为：");
print(y,n);
while(low<=hig) /*查找*/
{ mid=(low+hig)/2;
if(key ==y[mid].key)
return mid;
else if(key >y[mid].key)
low=mid+1;
else
hig=mid-1; }
return -1; }
/*直接插入排序*/
void insertsort(datatype x[],int n)
{ int i,j;
datatype temp; /*中间变量*/
for(i=1;i<n;i++)
{ temp=x[i];
j=i-1;
while(j>-1 && temp.key<x[j].key)
{ x[j+1]=x[j];
j--; }
x[j+1]=temp; } }
/*显示输出*/
void print(datatype x[],int n)
{ int i;
for(i=0;i<n;i++)
printf("%d\t",x[i]);
printf("\n"); }。