【C++】顺序查找与折半查找(附带解说)

合集下载

利用数组进行数据查找_折半查找法_C语言程序

利用数组进行数据查找_折半查找法_C语言程序
-12 0 6 16 23 [ 56 80 100 110 115 ]
↑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,须继续进行查找。
选定这批数中居中间位置的一个数与所查数比较看是否为所找之数若不是利用数据的有序性可以决定所找的数是在选定数之前还是在之后从而很快可以将查找范围缩小一半
适应情况:在一批有序数据中查找某数
基本思想:选定这批数中居中间位置的一个数与所查数比较,看是否为所找之数,若不是,利用数据的有序性,可以决定所找的数是在选定数之前还是在之后,从而很快可以将查找范围缩小一半。以同样的方法在选定的区域中进行查找,每次都会将查找范围缩小一半,从而较快地找到目的数

折半查找法c语言

折半查找法c语言

折半查找法c语言折半查找法,又称二分查找法,是一种在有序数据集(顺序表/列表、数组等)中,快速查找指定值的高效算法。

折半查找法的思想是基于二分法思想,用“分而治之”的思想来快速查找指定值。

折半查找法是一种最常用的查找方法,它也被称为是一种“有序”查找,因为要查找的数据必须是已经排好序的。

实际上,折半查找法的实现只要将有序的数据列折半,一次比较即可将待查找的值与被折半的数据列比较,这样查找的过程会比较快捷。

下面就来介绍折半查找法的具体实现方式:折半查找法假设要查找的数据是一个有序数列,在这里以升序数列为例:(1)先定义一个指向待查找序列低位的索引,称之为low;(2)定义另一个指向待查找序列高位的索引,称之为high;(3)首先用low与high计算中位索引 mid,将这个中位索引处的值与要查找的数据进行比较,如果相等,则搜索成功;(4)如果不等,则根据要查找的数据与中位索引处的值的比较结果,将待查找的序列分为两部分,下次查找只要在其中一部分序列中继续进行折半查找即可。

有了上面的思路,我们就可以用c语言来实现折半查找法了。

代码如下:#include<stdio.h>int binary_search(int arr[], int n, int key){int low, mid, high;low = 0;high = n-1;while(low <= high){mid = (low + high) / 2;if(arr[mid] == key)return mid;else if(arr[mid] > key)high = mid - 1;elselow = mid + 1;}return -1;}int main(){int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int res = binary_search(arr, 10, 7);printf(res = %d res);return 0;}以上就是一个最基本的折半查找法的实现,通过定义一个low、high和mid三个索引,在计算中位索引mid时,low和high 分别指向有序数列的低位和高位,根据判断条件,如果要查找的值等于中位索引处的数据,则查找成功,否则就用待查找的数据与中位索引处的数据进行比较,来确定下一次查找的范围。

c语言中常用的查找

c语言中常用的查找

c语言中常用的查找C语言中常用的查找引言:在编程中,查找是一项非常常见且重要的操作。

无论是在数组、链表、树还是图等数据结构中,都需要进行查找操作来寻找特定的数据或者确定某个元素的存在与否。

C语言提供了多种查找算法和数据结构,本文将介绍C语言中常用的查找方法。

一、线性查找线性查找是最简单的查找方法之一,也称为顺序查找。

其基本思想是从数据集合的起始位置开始逐个比较待查找元素与集合中的元素,直到找到目标元素或者遍历完整个集合。

在C语言中,可以使用for循环或者while循环实现线性查找。

线性查找的时间复杂度为O(n),其中n为数据集合中元素的个数。

二、二分查找二分查找又称为折半查找,是一种高效的查找算法,但要求数据集合必须是有序的。

其基本思想是将数据集合分为两部分,然后通过与目标元素的比较来确定目标元素在哪个部分中,从而缩小查找范围。

重复这个过程直到找到目标元素或者确定目标元素不存在于数据集合中。

二分查找的时间复杂度为O(logn),其中n为数据集合中元素的个数。

三、哈希表查找哈希表是一种通过哈希函数将关键字映射到存储位置的数据结构,它能够以常数时间复杂度O(1)进行查找操作。

在C语言中,可以使用数组和链表的结合来实现哈希表。

哈希表的关键之处在于哈希函数的设计,良好的哈希函数能够将关键字均匀地映射到不同的存储位置,从而提高查找效率。

四、二叉搜索树查找二叉搜索树是一种常用的数据结构,它满足以下性质:对于任意节点,其左子树中的所有节点的值都小于该节点的值,而右子树中的所有节点的值都大于该节点的值。

在C语言中,可以使用指针和递归的方式来实现二叉搜索树。

通过比较目标值与当前节点的值,可以确定目标值位于左子树还是右子树中,从而缩小查找范围。

五、图的遍历在图的数据结构中,查找操作通常是指遍历操作。

图的遍历有两种方式:深度优先搜索(DFS)和广度优先搜索(BFS)。

深度优先搜索通过递归的方式依次访问图中的每个节点,直到找到目标节点或者遍历完整个图。

c语言折半查找法代码

c语言折半查找法代码

c语言折半查找法代码折半查找法,也称二分查找法,是一种高效的查找算法。

它的基本思想是将有序数组分成两部分,通过比较中间元素和目标元素的大小关系,来确定目标元素在哪一部分中,然后再在该部分中继续进行查找,直到找到目标元素或者确定目标元素不存在为止。

下面是C语言实现折半查找法的代码:```#include <stdio.h>int binarySearch(int arr[], int left, int right, int target) {while (left <= right) {int mid = left + (right - left) / 2;if (arr[mid] == target) {return mid;} else if (arr[mid] < target) {left = mid + 1;} else {right = mid - 1;}}return -1;}int main() {int arr[] = {1, 3, 5, 7, 9, 11, 13, 15};int n = sizeof(arr) / sizeof(arr[0]);int target = 7;int index = binarySearch(arr, 0, n - 1, target);if (index == -1) {printf("目标元素不存在\n");} else {printf("目标元素在数组中的下标为:%d\n", index);}return 0;}```在上面的代码中,binarySearch函数接收四个参数:数组arr、左边界left、右边界right和目标元素target。

它通过while循环不断缩小查找范围,直到找到目标元素或者确定目标元素不存在为止。

其中,mid表示当前查找范围的中间位置,通过比较arr[mid]和target的大小关系来确定目标元素在哪一部分中。

数据结构——查找,顺序查找,折半查找

数据结构——查找,顺序查找,折半查找

实验五查找的应用一、实验目的: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的数据元素。

数据结构顺序查找与折半查找

数据结构顺序查找与折半查找

数据结构顺序查找与折半查找1,顺序查找顺序查找⼜称线性查找,它对顺序表和链表都适⽤。

(1)以下给出相关函数1 typedef struct{2 ElemType *elem; //元素存储空间地址,建表时按实际长度分配,0号单元留空3int TableLen; //表的长度4 }SSTable;5int Search_Seq(SSTable ST,ElemType key)6 {7 ST.elem[0]=key; //把要查找的关键字放在0号位置,称“哨兵”8for(int i=ST.TableLen;ST.elem!=key;i--) //从后往前找9 {10return i; //若表中不存在关键字为key的元素,将查找i=0时退出循环11 }12 }在上述算法中,将ST.elem[0]称为“哨兵”。

引⼊它的⽬的是使得Search_Seq内的循环不必判断数组是否会越界。

因为满⾜i=0时,循环⼀定会跳出。

除此之外,引⼊“哨兵”可以避免很多不必要的判断语句,从⽽提⾼算法的执⾏效率。

(2)算法效率分析当每个元素查找概率相同时,平均查找长度ASL=(n+1)/2, 查找不成功时,需要⽐较整个顺序表,所以⽐较次数时(n+1)次,从⽽顺序查找不成功的平均查找长度为(n+1)。

2.有序表的顺序查找(假设从⼩到⼤排列)有序表的顺序查找成功的平均查找长度与⼀般的线性表⼀样,即(n+1)/2.当查找失败时,待查找的元素为key,当查找第i个元素时,发现第i个元素的对应的关键字⼩于key,但第i+1个元素对应的关键字⼤于key,这时就可以返回查找失败的信息。

查找失败的平均查找长度为ASL=n/2+n/(n+1).3.折半查找前提:折半查找仅适⽤于有序的顺序表。

折半查找原理:将给定的key与中间元素⽐较,直到查到要找的元素。

以下是相关函数1int Binary_Search(SeqList L,ElemType key){2int low=0,high=L.TableLen-1,mid;//low指向表头,high指向表尾,mid中间值3while(low<=high)4 {5 mid=(low+high)/2;6if(L.elem[mid]==key) //中间值等于要查找元素7return mid;8else if(L.elem[mid]<key) //要查找元素在中间值右边9 low=mid+1;10else11 hign=mid-1; //要查找元素在中间值左边12 }13 }查找成功的时间复杂度为log2n,平均情况下⽐顺序查找效率⾼⼀些。

计算机数据结构知识点梳理 顺序查找法、折半查找法

计算机数据结构知识点梳理		顺序查找法、折半查找法
分析:这是一个在单链表中查找结点,在结点内查找给定值的过程。
typedef struct node{ int A[m];
//每个结点含有m个整数,本例m为5 struct node *next;
}LNode, *LinkList; typedef struct{
int j; //正整数在结点内的序号 LNode *s; //结点的指针 }rcd;
}
[题2]顺序存储的某线性表共有123个元素,按分块查找的要求等分为3块。若对索引 表采用顺序查找方法来确定子块,且在确定的子块中也采用顺序查找方法,则在等 概率的情况下,分块查找成功的平均查找长度为( )。
A.21
B. 23
C. 41
D. 62
分析:分块查找成功的平均查找长度为ASL=(s2+s+n)/2s。在本题中,n=123, s=123/3=41,故平均查找长度为23。
对表中每个数据元素的查找过程,可用二叉树来描述,称这个描述折半查找过 程的二叉树为判定树,表的中间结点是二叉树的根,左子表相当于左子树, 右子表相当于右子树。折半查找的过程是从根结点到待查找结点的过程,不 论查找成功或失败,查找长度均不超过树的高度,因此,如果有序表的长度 为n,那么在查找成功时与给定值进行比较的关键字个数至多为[㏒2n] +1。
4 、分块查找法
分块查找法要求将列表组织成以下索引顺序结构: (1)首先将列表分成若干个块(子表)。一般情况下,块的长度均匀, 最后一块 可以不满。每块中元素任意排列,即块内无序,但块与块之间有序。 (2)构造一个索引表。其中每个索引项对应一个块并记录每块的起始位置,以及每 块中的最大关键字(或最小关键字)。索引表按关键字有序排列。
假定将长度为n的表分成b块,且每块含s个元素,则b=n/s。又假定表中每个元素的查 找概率相等,则每个索引项的查找概率为1/b,块中每个元素的查找概率为1/s。

顺序查找直接查找折半查找算法

顺序查找直接查找折半查找算法

顺序查找直接查找折半查找算法一、顺序查找算法顺序查找也被称为线性查找,是一种简单直观的算法。

其基本原理是逐个遍历数据集中的元素,直到找到目标值为止。

算法步骤如下:1.从数据集的第一个元素开始顺序遍历。

2.如果当前元素与目标值相同,返回元素的索引。

3.如果遍历到数据集的最后一个元素仍未找到目标值,返回失败。

顺序查找算法的时间复杂度为O(n),其中n为数据集的大小。

由于需要遍历整个数据集,这种算法适用于小型数据集。

二、直接查找算法直接查找算法也被称为线性查找优化算法,其思想是在遍历数据集时,通过跳跃一定步长快速确定目标值所在的范围,然后在该范围内进行顺序查找。

算法步骤如下:1.设定步长为k。

2.从数据集的第一个元素开始,每次跳跃k个元素。

3.如果当前元素大于目标值,将步长减半并继续跳跃,直到找到目标值或步长变为1为止。

4.在跳跃范围内进行顺序查找,找到目标值则返回索引,否则返回失败。

直接查找算法的时间复杂度为O(n/k),其中n为数据集的大小,k为步长。

通过调整步长,可以在时间和空间之间取得平衡。

折半查找算法是一种效率较高的算法,也被称为二分查找。

其基本原理是将数据集分为两半,通过比较目标值与中间元素的大小关系来确定目标值所在的范围,然后在该范围内进行递归查找。

算法步骤如下:1.将数据集按升序或降序排列。

2.初始化左右指针,分别指向数据集的第一个和最后一个元素。

3.计算中间元素的索引。

4.如果中间元素等于目标值,则返回索引。

5.如果中间元素大于目标值,则更新右指针为中间元素的前一个元素,重复步骤36.如果中间元素小于目标值,则更新左指针为中间元素的后一个元素,重复步骤37.当左指针大于右指针时,返回失败。

折半查找算法的时间复杂度为O(logn),其中n为数据集的大小。

由于每次都将数据集分为两半,因此效率较高。

但是该算法要求数据集必须有序。

综上所述,顺序查找、直接查找和折半查找算法都是常用的算法,适用于不同规模和有序性的数据集。

数据结构C语言版_折半查找

数据结构C语言版_折半查找
(*ST).elem = NULL;
(*ST).length = 0;
return 1;
}
// 算法9.2 P220
// 在有序表ST中折半查找其关键字等于key的数据元素。若找到,则函数
// 值为该元素在表中的位置,否则为0。
int Search_Bin(SSTable ST,KeyType key)
{
int low, high, mid;
low = 1; // 置区间初值
high = ST.length;
while(low <= high)
{
mid = (low + high) / 2;
if(key == ST.elem[mid].key) // 找到待查元素
if( i )
print(st.elem[i]);
else
printf("没找到.\n");
Destroy(&st);
system("pause");
return 0;
}
/*
输出效果:
(5 1) (13 2) (19 3) (21 4) (37 5) (56 6) (64 7) (75 8) (80 9) (88 10) (92 11)
}
// 重建静态查找表为按关键字非降序排序
void Ascend(SSTable *ST)
{
int i, j, k;
for(i = 1; i < (*ST).length; i++)
{
k = i;
(*ST).elem[0] = (*ST).elem[i]; // 待比较值存[0]单元

C语言实现顺序表的顺序查找和折半查找

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语言

折半查找法c语言

折半查找法c语言【折半查找法(BinarySearch)是一种基于折半原理(分治思想)的搜索算法,它是用来定位一个给定值在已排序的数据结构中的位置。

折半查找法的步骤:(1)在有序表中取一个中间位置的记录(折半点);(2)如果待查记录和折半点记录相等,则查找成功,否则;(3)如果待查记录小于折半点记录,则在折半点的左半区继续折半查找;(4)如果待查记录大于折半点记录,则在折半点的右半区继续折半查找;(5)重复上述过程,直到找到待查记录或查找范围为空;(6)若查找范围为空,则表示待查记录不在表中,查找失败。

折半查找的查找步骤比较简单,它的时间复杂度为O(log2n),是相对于普通查找算法更有效率的一种搜索算法。

c语言中可以使用for循环、while循环或者recursive函数来实现折半查找法,以下是一个以循环方式实现的折半查找法代码:int Binary_Search(int arr[], int key, int left, int right) {int mid;while(left <= right){mid = (left + right) / 2;if (key == arr[mid]){return mid;}else if (key < arr[mid]){right = mid - 1;}else{left = mid + 1;}}return -1; //找失败}因为折半查找的最终查找范围只可能是一个记录,或是空,所以当right<left时,说明查找范围内没有元素,即查找失败。

折半查找法要求数据项必须处于排序状态,另外折半查找法只适用于静态查找表,对于需要频繁插入或删除的数据,折半查找法就不再适用了。

也就是说,若要使用折半查找法,就要求数据项必须处于排序状态,且数据表的大小不应该有太大变化,这样才能得到较好的查找效率。

折半查找法可用于多种数据结构中,如顺序表、单链表、二叉树等,这些数据结构中必须满足两个条件:(1)必须可以随机访问,即可以根据索引或下标随机访问某个元素;(2)数据结构必须已排序。

C语言算法排序与查找

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语言丨二分查找算法详解(含示例代码)

C语言丨二分查找算法详解(含示例代码)

C语⾔⼁⼆分查找算法详解(含⽰例代码)⼆分査找也称折半査找,其优点是查找速度快,缺点是要求所要査找的数据必须是有序序列。

该算法的基本思想是将所要査找的序列的中间位置的数据与所要査找的元素进⾏⽐较,如果相等,则表⽰査找成功,否则将以该位置为基准将所要査找的序列分为左右两部分。

接下来根据所要査找序列的升降序规律及中间元素与所查找元素的⼤⼩关系,来选择所要査找元素可能存在的那部分序列,对其采⽤同样的⽅法进⾏査找,直⾄能够确定所要查找的元素是否存在,具体的使⽤⽅法可通过下⾯的代码具体了解。

#include <stdio.h>binarySearch(inta[], intn, intkey){intlow = 0;inthigh = n - 1;while(low<= high){intmid = (low + high)/2;intmidVal = a[mid];if(midVal<key)low = mid + 1;elseif(midVal>key)high = mid - 1;elsereturnmid;}return-1;}intmain(){inti, val, ret;inta[8]={-32, 12, 16, 24, 36, 45, 59, 98};for(i=0; i<8; i++)printf("%d\t", a[i]);printf("\n请输⼈所要查找的元素:");scanf("%d",&val);ret = binarySearch(a,8,val);if(-1 == ret)printf("查找失败 \n");elseprintf("查找成功 \n");return0;}运⾏结果:-32 12 16 24 36 45 59 98请输⼊所要查找的元素:12查找成功在上⾯的代码中,我们成功地通过⼆分査找算法实现了查找功能,其实现过程如下图所⽰。

数据结构50:二分查找法(折半查找法)

数据结构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语言程序顺序查找和折半查找

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"); }。

C语言程序设计100例之(21):折半查找

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,表示每个待查找的元素。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
else if(x<a[mid]) up=mid-1; //如果所比较的元素比查找的小,则从元素值比较低的一方中查找
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;
else cout<< "未找到!"<< endl;
{
int i;
for(i=0;i<n;i++) //依次查找
if(x=a[i]) return i; //查找成功,则返回给【主函数】下标
return -1; //未找到,则返回给【主函数】-1
while(low<=up) //在最低元素与最高元素之间循环查找
{
mid=(low+up)/2; //计算比较中值下标
if(x==a[mid]) return mid; //将要查找的数同中间的元素对比,如果找到则输出mid值
}
void main() //定义【主函数】
ቤተ መጻሕፍቲ ባይዱ{
int array[]={1,45,85,12,36,2,49,6,13,8}; //初始化查找数组
int i,p,x;
cout<< "输入要查找的数:";
}
void main() //定义【主函数】
{
int array[]={1,2,4,5,23,41,54,56,69,78};//初始化查找数组,已按升序排列
int i,p,x;
cout<< "输入要查找的数:";
cin>> x;
else cout<< "未找到该数!" <<endl;
}
2、折半查找
#include <iostream.h>
#define M 10
int bi_search(int a[],int x,int n) //定义【查找函数】
{
int low=10,mid,up=n-1; //定义最低元素下标low,下标中间值mid,最高元素下标up
}
//折半查找法相当于数学中的二分法,即,在已经按照升序排列的数列中,比较查找数与中间数的大小,大,则说明查找数可能在较大的一半中
//则最低比较元素low应当从mid+1开始,反之,则说明查找数可能在较小的一半中,则最高比较元素up应当从mid-1开始
相关文档
最新文档