使用二分法实现数据查找c语言代码

c语言折中查找法折中查找法（也称为二分查找法）是一种在有序数组中查找特定元素的搜索算法。

搜索过程从数组的中间元素开始，如果中间元素正好是目标值，则搜索过程结束；如果目标值大于或小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且同样从中间元素开始比较。

如果在某一步骤数组为空，则代表找不到。

这种搜索算法每一次比较都使搜索范围缩小一半。

以下是一个用C语言实现的折中查找法：c复制代码#include<stdio.h>int binarySearch(int arr[], int l, int r, int x){if (r >= l) {int mid = l + (r - l) / 2;if (arr[mid] == x)return mid;if (arr[mid] > x)return binarySearch(arr, l, mid - 1, x); return binarySearch(arr, mid + 1, r, x); }return-1;}int main(void){int arr[] = {2, 3, 4, 10, 40};int n = sizeof(arr) / sizeof(arr[0]);int x = 10;int result = binarySearch(arr, 0, n - 1, x);(result == -1) ? printf("Element is not present in array"): printf("Element is present at index %d", result);return0;}这个程序首先定义了一个数组arr[]，然后使用binarySearch()函数查找特定的元素x。

如果x在数组中，函数将返回其索引；否则，返回-1。

二分查找 c语言（原创版）目录1.二分查找算法概述2.二分查找算法原理3.二分查找算法的 C 语言实现4.二分查找算法的应用示例5.总结正文【1.二分查找算法概述】二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。

搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。

如果在某一步骤数组为空，则代表找不到。

这种搜索算法每一次比较都使搜索范围缩小一半。

【2.二分查找算法原理】二分查找算法要求数组是有序的。

它的原理是：在有序数组中，要查找的元素只可能出现在数组的某个特定区间，而二分查找算法每次都将搜索范围缩小一半，直到找到要查找的元素或者搜索范围为空。

【3.二分查找算法的 C 语言实现】以下是二分查找算法的 C 语言实现代码：```c#include <stdio.h>int binary_search(int arr[], int len, int target) { int left = 0;int right = len - 1;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, 17, 19}; int len = sizeof(arr) / sizeof(arr[0]);int target = 13;int result = binary_search(arr, len, target);if (result!= -1) {printf("找到目标元素 %d，索引为 %d。

c语言实现二分查找的算法-回复【C语言实现二分查找的算法】引言：二分查找是一种非常常用且高效的搜索算法，适用于有序列表中元素的查找。

本文将介绍如何使用C语言实现二分查找的算法，并逐步解析其原理和代码实现。

一、什么是二分查找？二分查找，也称为折半查找，是一种基于比较的查找算法。

它的基本原理是将查找区间反复二分，直到找到目标元素或者区间为空为止。

因为每次查找都将查找区间缩小一半，所以该算法的时间复杂度为O(logn)，非常高效。

二、二分查找的前提条件二分查找算法要求查找的列表必须是有序的。

这意味着在进行二分查找前，我们需要首先对目标列表进行排序。

可以使用不同的排序算法，如冒泡排序、插入排序或快速排序等。

三、二分查找的步骤下面将详细介绍二分查找的步骤：1. 确定查找的起始位置和结束位置。

设定初始的查找区间为整个列表，也就是起始位置为0，结束位置为n-1，其中n为列表的长度。

2. 计算查找区间的中间位置。

找到起始位置和结束位置的中间位置，可以使用公式mid = (start + end) / 2。

3. 比较中间位置的元素与目标元素的大小。

将目标元素与中间位置的元素进行比较，如果相等，则找到了目标元素，返回结果；如果目标元素小于中间位置的元素，则将查找区间缩小为前半部分；如果目标元素大于中间位置的元素，则将查找区间缩小为后半部分。

4. 重复上述步骤，直到找到目标元素或者查找区间为空。

通过不断地缩小查找区间，二分查找算法最终会找到目标元素，或者确定目标元素不在列表中。

四、C语言实现二分查找的代码下面是一个使用C语言实现二分查找的代码示例：c#include <stdio.h>int binarySearch(int arr[], int target, int start, int end) { while (start <= end) {int mid = (start + end) / 2;if (arr[mid] == target) {return mid;}else if (arr[mid] < target) {start = mid + 1;}else {end = mid - 1;}}return -1; 表示未找到目标元素}int main() {int arr[] = {1, 3, 5, 7, 9, 11, 13};int target = 9;int n = sizeof(arr) / sizeof(arr[0]);int resultIndex = binarySearch(arr, target, 0, n - 1);if (resultIndex != -1) {printf("目标元素的索引为：d\n", resultIndex);}else {printf("未找到目标元素。

二分查找法c语言二分查找法是一种常用的查找算法，也称为折半查找法。

它的主要思想是将查找区间不断地二分，直到找到目标元素或者确定目标元素不存在为止。

在本文中，我将详细介绍二分查找法的原理、应用场景以及具体实现。

一、原理二分查找法的原理非常简单。

首先，需要将待查找的区间确定为一个有序序列。

然后，通过将区间的中间位置的元素与目标元素进行比较，可以确定目标元素位于区间的哪一部分。

若中间元素等于目标元素，则查找成功；若中间元素大于目标元素，则目标元素位于区间的左半部分；若中间元素小于目标元素，则目标元素位于区间的右半部分。

然后，将区间缩小为目标元素所在的那一部分，重复上述步骤，直到找到目标元素或者确定目标元素不存在。

二、应用场景二分查找法适用于有序序列的查找。

在实际应用中，它常被用于在数组或有序列表中查找特定元素的位置或判断某一元素是否存在。

由于二分查找法的时间复杂度为O(logn)，远小于线性查找法的O(n)，因此它在大规模数据的查找中具有较高的效率。

三、具体实现下面是一个使用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[] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};int target = 12;int n = sizeof(arr) / sizeof(arr[0]);int result = binarySearch(arr, 0, n - 1, target);if (result == -1) {printf("目标元素不存在\n");} else {printf("目标元素在数组中的位置为：%d\n", result);}return 0;}```在上述代码中，binarySearch函数接受一个有序数组arr、查找区间的左边界left、查找区间的右边界right以及目标元素target作为参数。

C语⾔的算法--------⼆分法查找int find(int n,int a[],int l){int low=0;int high=l-1;int middle=0;while(low<high){middle=(low+high)>>1;if(n==a[middle]){printf("%d,%d",n,middle);return 1;}else if(n>a[middle])low=middle+1;elsehigh=middle-1;}return 0;}int main(){int a[]={2,3,5,6,7,8,9,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60};int l=sizeof(a)/sizeof(a[0]);int i=0,n;printf("arry content");for(i=0;i<l;i++){if(i%8==0)printf("\n");printf("%4d",a[i]);}printf("\nseach n is ");scanf("%d",&n);if(!find(n,a,l))printf("not fond");return 0;}⼆分查找的基本思想是：（设R[low..high]是当前的查找区间）（1）⾸先确定该区间的中点位置：（2）然后将待查的K值与R[mid].key⽐较：若相等，则查找成功并返回此位置，否则须确定新的查找区间，继续⼆分查找，具体⽅法如下：　①若R[mid].key>K，则由表的有序性可知R[mid..n].keys均⼤于K，因此若表中存在关键字等于K的结点，则该结点必定是在位置mid左边的⼦表R[1..mid-1]中，故新的查找区间是左⼦表R[1..mid-1]。

实验课题：【用C描述课本的同学】有以下结构体构成的数组：struct StudentInfo{ char ID[10];char * name;float score;}StuInfo[12]={{"0800301105", "JACK", 95},{"0800201505", "LUN", 85},{"0400820115", "MARY", 75.5},{"0400850122", "KATE", 78.9},{"0500201011", "LILI", 88},{"0800401105", "JACK", 96},{"0600830105", "JAN", 98.4},{"0952520012", "SAM", 75},{"9721000045", "OSCAR", 64},{"0700301105", "JACK", 97},{"0458003312", "ZOE", 68.9},{"0400830211", "BOBI", 87.6}};对数组StuInfo按照学号（ID）递增排序，然后用二分查找的方法进行学号查找，若找到则输出该学生的全部信息，若找不到相应记录也给出提示；接下来，对该数组按照学分绩（score）递减排序后，使用二分查找法以学分绩作关键字进行查找。

用C++版教科书的同学：对MyBirds分别以name和ID为关键字排序，然后进行二分查找。

c语言数组二分法C语言中，数组是一组有序的元素，它们可以按照一定的规则进行排序。

二分法是一种常用的搜索算法，它可以快速地找到一个有序数组中指定值的位置。

在C语言中，可以通过以下步骤实现二分法：1. 确定数组的起始和结束位置2. 计算数组的中间位置3. 比较中间位置的值和目标值的大小关系4. 如果中间位置的值等于目标值，则返回该位置5. 如果中间位置的值小于目标值，则将起始位置移动到中间位置的下一个位置6. 如果中间位置的值大于目标值，则将结束位置移动到中间位置的上一个位置7. 重复步骤2-6，直到找到目标值为止。

以下是一个简单的C语言二分法实现示例：```c#include <stdio.h>int binarySearch(int arr[], int low, int high, int target) {while (low <= high) {int mid = low + (high - low) / 2;if (arr[mid] == target) {return mid;} else if (arr[mid] < target) {low = mid + 1;} else {high = mid - 1;}}return -1;}int main() {int arr[] = {1, 3, 5, 7, 9};int n = sizeof(arr) / sizeof(arr[0]);int target = 5;int index = binarySearch(arr, 0, n - 1, target); if (index != -1) {printf('目标值 %d 在数组中的位置是 %d', target, index);} else {printf('目标值 %d 不在数组中', target);}return 0;}```输出结果：目标值 5 在数组中的位置是 2在使用二分法进行搜索时，需要注意以下几点：1. 数组必须是有序的2. 如果数组中存在重复元素，可能无法找到目标值的确切位置3. 如果数组中没有目标值，算法可能会陷入死循环因此，在实际应用中，需要根据具体情况进行合理的处理，以保证算法的正确性和效率。

二分法c++代码二分法是一种在有序数组中查找特定元素的常用算法。

它通过将数组分成两部分并不断缩小搜索范围来快速定位目标元素。

以下是一个使用二分法在C++中查找特定元素的示例代码：```cpp#include <iostream>using namespace std;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[] = {2, 4, 6, 8, 10, 12, 14};int target = 8;int size = sizeof(arr) / sizeof(arr[0]);int result = binarySearch(arr, 0, size - 1, target);if (result == -1) {cout << '目标元素未找到' << endl;}else {cout << '目标元素在索引 ' << result << ' 处' << endl; }return 0;}```在上述代码中，我们定义了一个名为`binarySearch`的函数，它接受一个有序数组`arr`、左边界`left`、右边界`right`和目标元素`target`作为参数。

C基础算法之⼆分法查找算法：当数据量很⼤适宜采⽤该⽅法。

采⽤⼆分法查找时，数据需是排好序的。

基本思想：假设数据是按升序排序的，对于给定值x，从序列的中间位置开始⽐较，如果当前位置值等于x，则查找成功；若x⼩于当前位置值，则在数列的前半段中查找；若x⼤于当前位置值则在数列的后半段中继续查找，直到找到为⽌。

⼆分法查找在针对⼤量有序排列的情况下发挥出很优越的效率，这⾥以最具规律性的数组为例，代码如下：⽰例代码：/* binarysearch2.c ---** Filename: binarysearch2.c* Description: ⽤循环⽅式和递归两种⽅式实现⼆分法查找过程* Author: magc* Maintainer:* Created: 三 7⽉ 25 23:26:52 2012 (+0800)* Version:* Last-Updated: 四 7⽉ 26 00:22:37 2012 (+0800)* By: magc* Update #: 74* URL:* Keywords: 递归⼆分法查找* Compatibility:**//* Commentary:****//* Change Log:* 添加循环⽅式和递归⽅式**//* Code: */#include <assert.h>#include <ctype.h>#include <errno.h>#include <limits.h>#include <string.h>#include <stdarg.h>#include <stdlib.h>#include <stdio.h>int binarysearch(int arr[],int len,int key);int binarysearch2(int array[],int key,int low,int high);int main(int argc, char * argv[]){int array[] = {3,5,6,7,11,22,44,47 };int i;printf("请参照下列数组，输⼊你要查找的⽬标：\n {");int len = sizeof(array)/sizeof(int);for (i = 0; i < len; i++) {printf("%d,",array[i]);}printf("}:\n");int dest;scanf("%d",&dest);int res = binarysearch(array,len,dest);printf("1. res = %d\n",res);int res2 = binarysearch2(array,dest,0,len - 1);printf("2. res = %d\n",res2);}/**************************************************************************函数名称：⽤循环实现⼆分法查找过程,功能描述：输⼊参数：返回：返回⽬标值在数组中的下标**************************************************************************/int binarysearch(int arr[],int len,int key){int high,low;high = len - 1;//假设数组是从⼩到⼤排列的low = 0;int midle = len/2;while(high >= low){midle = (high + low)/2;if(arr[midle] == key)return midle;if(arr[midle] > key)high = midle - 1; //前提是假设数组是从⼩到⼤排序，否则不确定是该加1还是减1else if(arr[midle] < key )low = midle + 1;}return (-1);}/**************************************************************************函数名称：⽤递归实现⼆分法查找功能描述：输⼊参数：返回：**************************************************************************/int binarysearch2(int array[],int key,int low,int high){if (low >= high)return (-1);int midle = (low + high)/2;if(array[midle] == key)return midle;if(midle == high || midle == low) //此时，只剩下了下标为high和low的两个数，确定另⼀个数不是key后，就确定查找完毕，并且未找到⽬标值 {if(array[high] == key)return high;else if(array[low] == key)return low;elsereturn (-1);}else if(array[midle] > key)return binarysearch2(array,key,low,midle); //由于不确定排序⽅向，所以此处只能⽤midle值，⽽不能加1或减1else if(array[midle] < key) //当中间值⼩于⽬标值时，在high的⼀侧继续查找，low变到midle位置上return binarysearch2(array,key,midle,high);}/* binarysearch2.c ends here */在GCC下编译运⾏结果如下：注：1）在第⼀个⽅法中，要体会到⼆分法查找的思路，设置high和low参数的好处是，不论数组是从⼤到⼩还是从⼩到⼤排列，此函数皆适⽤。

二分查找c语言-回复二分查找是一种常用的查找算法，也被称为折半查找。

它在已经排序好的数组中查找目标元素的位置，通过将数组分成两半，然后逐步缩小查找范围来提高效率。

本文将详细解释二分查找的原理，并给出其在C语言中的实现方法。

一、原理解释二分查找的核心思想是将查找范围不断分为两半。

具体步骤如下：1. 首先将数组的中间元素与目标元素进行比较。

如果相等，则表示找到目标元素，返回其索引；2. 如果目标元素小于中间元素，则将查找范围缩小为左半部分，再次进行比较；3. 如果目标元素大于中间元素，则将查找范围缩小为右半部分，再次进行比较；4. 重复以上步骤，直到找到目标元素或者查找范围缩小至只剩下一个元素。

二、实现步骤在C语言中，可以通过递归或者迭代的方式实现二分查找算法。

以下是一种基于迭代的实现方法。

Step 1: 定义二分查找函数首先，我们需要定义一个函数来执行二分查找。

该函数接收三个参数：数组arr，数组的左边界left和数组的右边界right。

函数返回目标元素的索引，如果找不到则返回-1。

cint binarySearch(int arr[], int left, int right, int target) {实现二分查找算法}Step 2: 实现二分查找算法在`binarySearch`函数中，我们按照之前的步骤实现二分查找算法。

首先检查数组范围是否合法，如果不合法则返回-1。

cint binarySearch(int arr[], int left, int right, int target) { if (left <= right) {实现二分查找算法}return -1; 范围不合法，返回-1}Step 3: 执行二分查找在合法范围内，我们要找到数组的中间元素，然后与目标元素比较。

如果相等则返回中间元素的索引；如果目标元素小于中间元素，则将右边界缩小为中间元素的索引减一，否则将左边界扩大为中间元素的索引加一。

二分查找 c语言【原创版】目录1.二分查找算法的定义2.二分查找算法的基本原理3.二分查找算法的实现步骤4.二分查找算法的优势与应用场景5.C 语言中实现二分查找算法的示例代码正文一、二分查找算法的定义二分查找算法（又称折半查找算法）是一种在有序数组中查找特定元素的高效算法。

它的基本思想是将待查找的元素与有序数组的中间元素进行比较，根据比较结果进行下一步查找，直到找到目标元素或确定目标元素不存在为止。

二、二分查找算法的基本原理1.有序数组中，中间元素将数组分为两个部分，左侧部分所有元素均小于中间元素，右侧部分所有元素均大于中间元素。

2.如果待查找的元素小于中间元素，则在左侧部分继续查找；反之，在右侧部分继续查找。

3.随着查找的进行，待查找的元素范围逐渐缩小，最终可得到目标元素或确定目标元素不存在。

三、二分查找算法的实现步骤1.确保数组是有序的。

2.确定初始的左右指针，分别指向数组的第一个元素和最后一个元素。

3.比较待查找元素与中间元素的大小，根据比较结果更新左右指针。

4.重复步骤 3，直到找到目标元素或确定目标元素不存在。

四、二分查找算法的优势与应用场景1.时间复杂度：二分查找算法的时间复杂度为 O(logn)，相较于顺序查找的 O(n) 时间复杂度更优秀。

2.适用场景：在数据量较大且数据有序的情况下，二分查找算法能够显著提高查找效率。

五、C 语言中实现二分查找算法的示例代码```c#include <stdio.h>int binary_search(int arr[], int len, int target) {int left = 0;int right = len - 1;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 len = sizeof(arr) / sizeof(arr[0]);int target = 11;int result = binary_search(arr, len, target);if (result!= -1) {printf("找到目标元素，索引为：%d", result);} else {printf("目标元素不存在");}return 0;}```通过以上内容，我们可以了解到二分查找算法的基本原理、实现步骤以及在 C 语言中的应用。

C语⾔实现折半查找法（⼆分法）折半查找法也叫做⼆分查找，顾名思义，就是把数据分成两半，再判断所查找的key在哪⼀半中，再重复上述步骤知道找到⽬标key;注意：折半查找法仅适⽤于对已有顺序的数组、数据进⾏操作很显然，折半查找法相对于其他查找⽅法例如顺序查找法效率要⾼很多；下⾯我们来实际操作⼀下，了解⼆分查找的奥义。

例如：要在数组arr[]={8,7,9,6,4,1,2,5,3,10,11};中查找key=7的位置；⾸先，我们要先将数组arr中的数据成员进⾏排序。

arr[]= {1,2,3,4,5,6,7,8,9,10,11};如图所⽰：将该组数据⼩端记作low，⼤端记作high,中间值记作mid;⼆分法查找时，将所查找的key与mid⽐较，例如key=7，即可缩⼩查找范围在mid和high之间；如图所⽰即可找到key=low=7;注意：（敲⿊板）如果中间数mid不是整数，需要进⾏取整。

代码如下：#include<stdio.h>int BinSearch(int arr[],int len,int key) //折半查找法（⼆分法）{int low=0; //定义初始最⼩int high=len-1; //定义初始最⼤int mid; //定义中间值while(low<=high){mid=(low+high)/2; //找中间值if(key==arr[mid]) //判断min与key是否2020111122411718相等return mid;else if(key>arr[mid]) //如果key>mid 则新区间为[mid+1,high]low=mid+1;else //如果key<mid 则新区间为[low,mid-1]high=mid-1;}return -1; //如果数组中⽆⽬标值key，则返回 -1 ；}int main(){int arr[]={1,2,3,4,5,6,7,8,9,10,11}; //⾸先要对数组arr进⾏排序printf("%d \n",BinSearch(arr,(sizeof(arr)/sizeof(arr[0])),7));return 0;}运⾏结果如下：希望对您有所帮助！以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

#include <stdio.h>#include <stdlib.h>#include <malloc.h>typedef struct bitnode{char data;struct bitnode *lchild, *rchild;}bitnode, *bitree;void createp(t)bitnode **t;{char x;bitnode *q;printf("\n x=:");x=getchar();if (x!='\n') getchar();q=(bitnode*)malloc(sizeof(bitnode));q->data=x;q->lchild=NULL;q->rchild=NULL;*t=q;if (q->data!='$') printf("%o,%c,%o,%o",q,q->data,q->lchild,q->rchild); return;}void find(p,t)bitnode *p,**t;{bitnode *q,*f;if (*t==NULL) *t=p;else{q=*t;f=NULL;while (q!=NULL){if (p->data > q->data){f=q; q=q->rchild;}else {f=q;q=q->lchild;}}if (p->data>f->data) f->rchild=p;else f->lchild=p;}}void createbst(t)char **t;{bitnode *p;while (p->data!='$'){createp(&p);if (p->data=='$') return;find(p,t);}}void visit(e)bitnode *e;{printf(" %o,%c,%o,%o\n",e,e->data,e->lchild,e->rchild);}void preordertraverse(t)bitnode *t;{if(t){visit(t);preordertraverse(t->lchild);preordertraverse(t->rchild);return ;}else return ;}void searchbst(t,k)bitnode *t;char k;{if (!t) printf("\n can not find it\n");else if (k==t->data)printf("\nfind it is %o %c %o %o\n",t,t->data,t->lchild,t->rchild);else if (k<t->data) searchbst(t->lchild,k);else searchbst(t->rchild,k);}main(){bitnode *t=NULL;char k;printf("input char; input '$' for end:" ); createbst(&t);preordertraverse(t);printf("\ninput char for searchbst:");k=getchar();searchbst(t,k);}。

经典c语言二分法二分法的时间复杂度为O(logn)，是一种高效的查找算法，在处理大型数据集时非常实用。

本文将通过C语言实现二分法的基本原理和应用，以帮助读者更深入地理解这一经典算法。

1. 二分法的基本原理在有序数组中查找目标元素时，二分法的基本思路是不断地将当前查找范围缩小为一半，直到找到目标元素或者确定目标元素不存在于数组中。

具体步骤如下：（1）首先确定查找范围的起始位置start和结束位置end，初始化为数组的第一个和最后一个元素的下标。

（2）计算当前查找范围的中间位置mid，即mid = (start + end) / 2。

（3）比较目标元素与数组中间位置的元素的大小关系，如果相等则找到目标元素，返回对应的下标；如果目标元素比中间位置的元素大，则将查找范围缩小为[mid+1, end]；如果目标元素比中间位置的元素小，则将查找范围缩小为[start, mid-1]。

（4）重复步骤（2）和（3），直到找到目标元素或者确定目标元素不存在于数组中。

二分法的核心思想就是不断地将查找范围缩小为一半，通过对比目标元素和中间位置的元素的大小关系进行迭代，最终找到目标元素的位置。

2. 二分法的C语言实现接下来我们将通过C语言来实现二分法的基本原理。

首先我们定义一个简单的有序数组作为示例，然后编写二分法查找目标元素的函数。

```c#include <stdio.h>// 二分法查找目标元素的函数int binarySearch(int arr[], int n, int target) {int start = 0;int end = n - 1;while (start <= end) {int mid = (start + end) / 2;if (arr[mid] == target) {return mid; // 找到目标元素，返回下标}else if (arr[mid] < target) {start = mid + 1; // 缩小查找范围为[mid+1, end] }else {end = mid - 1; // 缩小查找范围为[start, mid-1]}}return -1; // 目标元素不存在于数组中}int main() {int arr[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int n = sizeof(arr) / sizeof(arr[0]);int target = 13;int result = binarySearch(arr, n, target);if (result != -1) {printf("目标元素%d的下标为%d\n", target, result); }else {printf("目标元素%d不存在于数组中\n", target);}return 0;}```上述代码中，我们首先定义了一个有序数组arr作为示例，然后编写了二分法查找目标元素的函数binarySearch。

#include <stdio.h>//递归算法int recurbinary(int *a,int key,int low,int high){int mid;if(low > high)return -1;mid = (low + high)/2;if(a[mid] == key) return mid;else if(a[mid] > key)return recurbinary(a,key,low,mid -1);elsereturn recurbinary(a,key,mid + 1,high);}//非递归算法[1]int binary( int *a, int key, int n ){int left = 0, right = n - 1, mid = 0;mid = ( left + right ) / 2;while( left < right && a[mid] != key ){if( a[mid] < key )left = mid + 1;else if( a[mid] > key )right = mid - 1;mid = ( left + right ) / 2;}if( a[mid] == key )return mid;return -1;}int main(){int a[] = {1,2,3,4,5,6,7,8,9,12,13,45,67,89,99,101,111,123,134,565,677}; int b[] = { 677, 1, 7, 11, 67 };int i;for( i=0; i<sizeof(b)/sizeof(b[0]); i++ ){printf( "%d\n", recurbinary(a,99,0,sizeof(a)/sizeof(a[0])-1) );//printf( "%d\n", binary( a, 45, sizeof(a)/sizeof(a[0])-1 ));}return 0;}#include<iostream>#define N 10using namespace std;int main(){int a[N],front,end,mid,x,i;cout<<"请输入已排好序的a数组元素:"<<endl; for(i=0;i<N;i++)cin>>a[i];cout<<"请输入待查找的数x:"<<endl;cin>>x;front=0;end=N-1;mid=(front+end)/2;while(front<end&&a[mid]!=x){if(a[mid]<x)front=mid+1;if(a[mid]>x)end=mid-1;mid=(front+end)/2;}if(a[mid]!=x)printf("没找到！\n");elseprintf("找到了，在第%d项里",mid+1);return 0;}。