C语言程序-顺序查找和折半查找
查找排序
解：① 先设定3个辅助标志: low,high,mid， 显然有：mid= (low+high)/2 ② 运算步骤：
(1) low =1,high =11 ,故mid =6 ，待查范围是 [1,11]； (2) 若 S[mid] < key，说明 key[ mid+1,high] ， 则令：low =mid+1;重算 mid＝ (low+high)/2；. (3) 若 S[mid] > key，说明key[low ,mid-1]， 则令：high =mid–1;重算 mid ； (4)若 S[ mid ] = key，说明查找成功，元素序号=mid; 结束条件： （1）查找成功 ： S[mid] = key （2）查找不成功 ： high＜low （意即区间长度小于0）
while(low<=high)
{ mid=(low+high)/2; if(ST[mid].key= = key) return (mid); /*查找成功*/
else if( key< ST[mid].key) high=mid-1; /*在前半区间继续查找*/ else } return (0); /*查找不成功*/
4 5 6 7
0
1
2
90
10
(c)
20
40
K=90
80
30
60
Hale Waihona Puke 25(return i=0 )
6
讨论：怎样衡量查找效率？
——用平均查找长度（ASL）衡量。
如何计算ASL？
折半查找程序
先看看这个，下面有例子折半查找：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。
因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
算法要求算法复杂度下面提供一段二分查找实现的伪代码: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的数据元素。
C语言常用算法
八、常用算法（一）考核知识要点1．交换、累加、累乘、求最大（小）值2．穷举3．排序（冒泡、插入、选择）4．查找（顺序、折半）5．级数计算（递推法）6．一元方程求解（牛顿迭代法、二分法）7．矩阵（转置）8．定积分计算（矩形法、梯形法）9．辗转相除法求最大公约数、判断素数10．数制转换（二）重点、难点精解教材中给出的算法就不再赘述了。
1．基本操作：交换、累加、累乘1）交换交换算法的要领是“借助第三者”（如同交换两个杯子里的饮料，必须借助第三个空杯子）。
例如，交换两个整型变量里的数值：int a=7,b=9,t;t=a; a=b; b=t;(不借助第三者，也能交换两个整型变量里的数值，但不通用，只是一个题目而已。
例如：int a=7,b=9; a=a+b; b=a-b; a=a-b;)2）累加累加算法的要领是形如“s=s+A”的累加式，此式必须出现在循环中才能被反复执行，从而实现累加功能。
“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为0。
3）累乘累乘算法的要领是形如“s=s*A”的累乘式，此式必须出现在循环中才能被反复执行，从而实现累乘功能。
“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为1。
2．非数值计算常用经典算法1）穷举法也称为“枚举法”，即将可能出现的各种情况一一测试，判断是否满足条件，一般采用循环来实现。
例如，用穷举法输出“将1元人民币兑换成1分、2分、5分硬币”的所有方法。
main(){int y,e,w;for(y=0;y<=100;y++)for(e=0;e<=50;e++)for(w=0;w<=20;w++)if(1*y+2*e+5*w==100)printf("%d,%d,%d\n",y,e,w);}2）有序序列的插入算法就是将某数据插入到一个有序序列后，该序列仍然有序。
以下给出用数组描述该算法的例子：将x插入一升序数列后，数列仍为升序排列。
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"); }
折半查找算法及程序实现教案
折半查找算法及程序实现教案教案：折半查找算法及程序实现一、教学目标1.了解折半查找算法的原理和流程；2.掌握折半查找算法的程序实现；3.能够分析和评估折半查找算法的时间复杂度。
二、教学内容1.折半查找算法的原理和流程；2.折半查找算法的程序实现；3.折半查找算法的时间复杂度分析。
三、教学过程1.导入，引入折半查找算法的背景和应用场景。
（5分钟）2.讲解折半查找算法的原理和流程。
（10分钟）折半查找算法，也称为二分查找算法，是一种分治思想的算法。
其运行时要求待查找数据必须是有序的。
基本思想是将待查找的数据与中间位置的数据进行比较，若相等则查找成功，若不相等则根据大小关系在前半部分或后半部分查找，如此不断缩小查找范围，直到找到目标元素或查找范围为空。
1）取查找范围的首尾元素确定中间位置元素，并与目标元素进行比较；2）若中间位置元素与目标元素相等，则查找成功，返回中间位置；3）若中间位置元素大于目标元素，则在前半部分继续查找，重复步骤1）；4）若中间位置元素小于目标元素，则在后半部分继续查找，重复步骤1）；5）若找到目标元素，则返回其位置，否则返回查找失败。
3.分组讨论与实践。
（15分钟）将学生分成若干小组，让每个小组分别完成以下任务：-根据讲解的折半查找算法原理，结合自己的理解，用自然语言描述折半查找算法；-编写折半查找算法的递归实现；-编写折半查找算法的非递归实现；-利用给定的有序数组，测试实现的算法是否正确。
4.小组展示与讨论。
（15分钟）每个小组派代表上台展示他们的实现，并陈述实现的思路和步骤。
其他小组可对其实现进行评议和提问，共同讨论折半查找算法的优化和改进。
5.整合和总结。
（10分钟）将小组讨论的结果整合起来，总结折半查找算法的特点和程序实现的要点。
6.展示折半查找算法的时间复杂度分析。
（10分钟）通过一张时间复杂度的图示，讲解折半查找算法的时间复杂度是log(n)级别的，并与线性查找算法进行对比，强调折半查找算法的高效性。
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语言排序与查找
排序与查找1.选择排序算法：N元数组a[0]~a[N-1]由小到大排序：第0步:找到a[0]~a[N-1]中的最小值元素与a[0]交换;第1步:找到a[1]~a[N-1]中的最小值元素与a[1]交换；第2步:找到a[2]~a[N-1]中的最小值元素与a[2]交换；…第i步:找到a[i]~a[N-1]中的最小值元素与a[i]交换;…第N-2步:找到a[N-2]~a[N-1]中的最小值元素与a[N-2]交换。
算法停止。
思考：由大到小排序算法如何改动？#include "stdio.h"#define N 10void SelSort(int a[N]) { /*选择排序函数*/int i,j,minj,t;for (i = 0;i < N-1;i++) {for (j = i + 1;j < N;j++)if(a[j] < a[i]) {t = a[i];a[i] = a[minj];a[minj] = t;}}}这样中间有些交换是没有必要的，设定一个minj变量记录当前一趟最小值的下标。
可以减少变量交换的次数。
改进如下：void SelSort(int a[N]) { /*改进选择排序函数*/int i,j,minj,t;for (i = 0;i < N-1;i++) {minj = i;for (j = i + 1;j < N;j++)if(a[j] < a[minj])minj = j;if(minj != i) {t = a[i];a[i] = a[minj];a[minj] = t;}}}void main(){int a[N],i;for(i = 0;i < N;i++)scanf("%d",a + i);SelSort(a);for (i = 0;i < N;i++)printf("%6d",a[i]);}2.插入排序引例：写一个函数，将一个整型数x插入到由小到大排列的整型数组a[0]~a[N-1]中，使得插入元素后的数组a[0]~a[N]保持升序。
顺序查找与折半查找实验报告
顺序查找与折半查找实验报告姓名：许严班级：计122 学号：12130230501.问题描述实现顺序查找与折半查找的程序设计，并比较两种查找方法的性能。
2.基本要求（1）设计查找表的存储结构。
（2）设计查找算法，对同一组实验数据实现查找。
（3）输入：查找表的数据个数和数据由键盘输入，数据元素类型为整型，以菜单方式选择顺序查找或折半查找中的一种，并由键盘输入想要查找的数据。
（4）输出：若查找成功输出其位置和查找次数，若查找失败输出信息和查找次数。
3.实现提示（1）存储设计由于要对一组实验数据实现顺序查找与折半查找，只能采用顺序表存放查找表数据，存储结构定义与教材一致。
设关键字类型为整型，利用前面实验建立的线性表类，生成一个线性表对象，线性表中的数据个数、数据以及待查找的数据由键盘输入。
（2）算法设计由于折半查找法要求数据是有序的，可设立一个创建有序顺序表的函数Sort(int*fp,int length)；设立一个顺序查找函数SequenSearch(int*fp,int length)实现顺序查找；设立一个折半查找函数实现折半查找；编写一个主函数main(),在主函数中设计一个简单的菜单，根据用户的选择分别调用顺序查找和折半查找算法。
4.程序设计(1) using namespace std;struct Node{int key;};class SSearch{private:Node *ST;int len;public:SSearch();~SSearch();void Create(int n);void Display();void Sort();void Sort_n(int arr[]);void SequenceSearch(int key);void Search(int key);};SSearch::SSearch(){ST=0;len=0;}SSearch::~SSearch(){if(ST) delete[]ST;len=0;}void SSearch::Create(int n){len=n;ST=new Node[len];cout<<"请输入"<<n<<"个数据元素：\n";int i=0;while(i<len){cin>>ST[i].key;i++;}cout<<"静态表创建成功！：）\n";}void SSearch::Display(){cout<<"表中数据元素依次为：\n";for(int i=0;i<len;i++)cout<<ST[i].key<<'\t';cout<<endl;}voidSSearch::Sort() //冒泡排序{int t;for(int i=1;i<len;i++){bool y=1;for(int j=0;j<len-i;j++){if(ST[j].key>ST[j+1].key){t=ST[j].key;ST[j].key=ST[j+1].key;ST[j+1].key=t;y=0;}}if(y) return;}}void SSearch::Sort_n(int arr[]){int t;for(int i=1;i<len;i++){bool y=1;for(int j=0;j<len-i;j++){if(arr[j]>arr[j+1]){t=arr[j];arr[j]=arr[j+1];arr[j+1]=t;y=0;}}if(y) return;}}void SSearch::SequenceSearch(int key){ST[0].key=key;int count=1,i=len-1; //计数边梁count为1的原因是下面的for语句先判定在count++ for(;ST[i].key!=key;i--,count++);if(i){cout<<"查找成功！\n在顺序表的第"<<i<<"个位置（从0开始），一共比较了"<<count<<"次。
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
折半查找法的优化与改进
二分查找的变种
线性二分查找
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[],intn);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[],intn){ 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"); }。
数据结构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语言程序设计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，表示每个待查找的元素。
折半查找描述的算法
折半查找描述的算法
折半查找（Binary Search）是一种查找算法，适用于已排序数组或列表。
其算法步骤如下：
1. 初始化一个左指针left和一个右指针right。
left指向数组的起始位置，right 指向数组的末尾位置。
2. 计算中间位置mid = (left+right) / 2。
如果数组的大小为奇数，则mid是中间元素的索引；如果数组的大小为偶数，则mid是中间两个元素中的较小索引。
3. 比较中间元素[mid]和目标值target的大小。
- 如果[mid] == target，则找到目标值，返回mid。
- 如果[mid] < target，则目标值可能在[mid+1, right]之间，更新left = mid + 1，重复步骤2。
- 如果[mid] > target，则目标值可能在[left, mid-1]之间，更新right = mid - 1，重复步骤2。
4. 重复步骤2和步骤3，直到left > right或者找到目标值。
如果找到目标值，则返回其索引；如果找不到目标值，则返回-1。
折半查找的时间复杂度为O(log n)，其中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"); }。