c语言二分法查找法的图形演示程序
反序数组二分法查找元素c语言
反序数组二分法查找元素c语言如果你要在一个已经按照递增顺序排列的反序数组中使用二分法查找元素，你需要在二分查找的基础上进行一些修改。
以下是一个使用C 语言实现的例子，演示了如何在反序数组中进行二分查找：```c#include <stdio.h>int binarySearchInReverse(int arr[], int low, int high, int target) {while (low <= high) {int mid = low + (high - low) / 2;if (arr[mid] == target) {return mid; // 元素找到，返回索引}// 判断在哪一侧递增if (arr[mid] < arr[low]) {// 右侧递增if (target > arr[mid] && target <= arr[high]) {low = mid + 1; // 在右侧继续查找} else {high = mid - 1; // 在左侧继续查找}} else {// 左侧递增if (target >= arr[low] && target < arr[mid]) {high = mid - 1; // 在左侧继续查找} else {low = mid + 1; // 在右侧继续查找}}}return -1; // 元素未找到}int main() {int arr[] = {6, 5, 4, 3, 2, 1}; // 反序数组int n = sizeof(arr) / sizeof(arr[0]);int target = 3;int result = binarySearchInReverse(arr, 0, n - 1, target);if (result != -1) {printf("Element found at index %d\n", result);} else {printf("Element not found in the array\n");}return 0;}```这个例子中的`binarySearchInReverse` 函数对标准的二分查找进行了修改，以适应反序数组。
二分法查找c语言程序
二分法查找c语言程序二分法查找是一种在有序数组中查找某个特定值的技术，其核心思想是：首先选取数组中间位置的元素，如果该元素正好是要查找的元素，则查找过程结束；如果该元素大于要查找的元素，则在数组的前半部分再进行查找；如果该元素小于要查找的元素，则在数组的后半部分再进行查找。
重复以上过程，直到找到要查找的元素，或者查找范围为空。
用c语言实现二分法查找的程序：#include <stdio.h> // 声明函数 int binarySearch(int arr[], int left, int right, int key); // 主函数 int main() { // 定义数组int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; // 计算数组的大小 int size = sizeof(arr) /sizeof(arr[0]); // 要查找的元素 int key = 4; // 用二分法查找 int result = binarySearch(arr, 0, size - 1, key); // 打印查找结果 if (result == -1) printf("元素不存在\n"); else printf("元素位置为：%d\n", result); return 0; } // 二分法查找函数 int binarySearch(int arr[], int left, intright, int key) { // 定义中间位置 intmid; // 当左侧位置小于右侧位置时，循环查找while (left <= right) { // 求出中间位置 mid = (left + right) / 2; //如果查找的key值等于中间位置的元素，则返回元素位置if (key == arr[mid]) return mid;// 如果查找的key值大于中间位置的元素，则从数组的右半部分开始查找 else if (key > arr[mid]) left = mid + 1; // 如果查找的key值小于中间位置的元素，则从数组的左半部分开始查找else right = mid - 1; } //如果查找不到，则返回-1 return -1; }。
算法图解（二分查找）
算法图解（⼆分查找）⼆分查找假设你要查找电话本⾥k开头的⼈⾥可能会直接滑动到中间因为你知道k在中间位置因为电话本是abcdef排序的嘛定义：⼆分查找就指从中间开始查找的逻辑做法注：# ⼆分查找必须是有序序列返回其位置# ⽆序⽆法进⾏⼆分查找返回null例如：⼆分查找： 利⽤⼆分查找每次取中间数有⼩数可以向上或向下取整数 100以内的数字最多7次可以找出来普通查找： ⽽普通查找则是从头到位遍历最好的情况是1 ⼀次找出最差是100次⼆分查找随着元素的增加并不会改变太⼤普通查找则会随元素的增加⽽增加⽐如说⼀个字典内有240000个单词普通查找最差情况：240000次出结果⼆分查找最差情况：17次出结果这就很明显的突出了⼆分算法的优势####这⾥我⽤（）括号⾥的数字代表log的下标⽤⼆分查找最多需要log（2）n步其实就是利⽤对数运算：对数运算：定义：幂运算的逆运算例如：10**2 = 100 log（10）100 = 210**3 = 1000 log（10）1000=32**5 = 32 log（2）32 = 5如果有8个元素你最多需要查找3次因为long8 = 3（2**3=8）1024个元素最多需要检查10个元素因为 1024 = 10（2**10=1024）def binary(lst, item):low = 0high = len(lst) - 1while low <= high:mid = round((low + high) / 2)guess = lst[mid]if guess == item: # 猜对了return midif guess > item:high = mid - 1 # 猜⼤了else:low = mid + 1 # 猜⼩了return Nonemy_list = [1, 3, 5, 7, 9]print(binary(my_list, 3)) # 1 返回的元素下标索引是0开始的print(binary(my_list, -1)) # None 因为不存在-1元素运⾏时间： 线性时间（linear time） 100个数字最多猜100次 40亿猜40亿次最多猜的次数等于列表的长度 对数时间（或log时间） 100个数字最多猜7次 40亿猜32次⼤O表⽰法： 简单查找每个元素需要n次运⾏时间为O（n） ⼆分查找运⾏时间为O（log（n））⼤O表⽰法计算的是操作数 O（log n）对数时间包括⼆分查找 O（n）线性时间 O（n * log n）快速排序算法 O（n**2）速度较慢排序法算法 O（n！）⾮常慢的算法⼩结： ⼆分查找⽐简单查找快的多 O（log n）⽐O（n）快，需要搜索的元素越多，前者⽐后者就快的越多 算法运⾏时间并不以秒为单位 算法运⾏时间是从其增速的⾓度度量的 算法的运⾏时间⽤⼤O表⽰法表⽰。
C语言的算法--------二分法查找
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]。
二分法的动画演示课件
40 high
A(40)
要查找的数据是 key
mid=int((low+high)/2)
Key=a(mid) 找到了
Key>a(mid) low=mid+1 Key<a(mid)
思考 1
low
A(1)
A(1)
A(1)
20
·mid
A(20)
40 high
A(40)
21 low
A(21)
·30
Key=a(mid) 找到了
Key>a(mid) low=mid+1 Key<a(mid) high=mid-1
·21 22 24
low mid high
A(21) A(22) A(24)
A(40)
思考 1
low
A(1)
A(1)
A(1)
A(1) A(1)
20
·mid
A(20)
40 high
A(40)
二分查找（对分查找）
查找条件： 被查找的数据必须是有序的。
基本思想： 在有序的数据列中，首先将要查找的数据与有序数组
内处于中间位置的数据进行比较，如果两者相等，则查 找成功；否则根据数组元素的有序性，就可确定该数据 应该在数组的前半部分还是后半部分继续进行查找；在 新确定的范围内，继续按上述方法进行查找，直到找到 要查找的数据，即查找成功，或直到子表不存在，即查 找不成功。
21 low
A(21)
·30
mid
A(30)
40 high
A(40)
21 Low
·25 29 mid high
A(21) A(25) A(29)
数据结构C语言实现二分查找
实验课题：【用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语言中，数组是一组有序的元素，它们可以按照一定的规则进行排序。
二分法是一种常用的搜索算法，它可以快速地找到一个有序数组中指定值的位置。
在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语⾔）⼆分法是⼀种⾼效的查找⽅法，其适⽤于已经排好序的数组基本思路从数组最中间的数开始查找判断，若不是需要查找的数字，则⽐较⼤⼩，之后则在从中间分开的两边中的⼀边从最中间开始查找判断，以此类推算法描述这⾥以升序数组为例，降序数组类似1. 记录数组最中间数的下标，将其中的数与要查找的数进⾏⽐较2. 若相等，停⽌查找，若⼤于要查找的数，则将数组下标上限换为较⼤半区的最⼩下标；若⼩于要查找的数，则将数组下标的下限换为较⼩半区的最⼤下标3. 重复第⼀步，直到数组下标不能调换，若查找到则停⽌查找，若未找到，则返回不存在的结果代码实现这⾥以升序数组为例，降序数组类似# include<stdio.h>int f(int, int [], int);int main(){int n;int arr[10]={1,2,3,4,5,6,7,8,9,10};scanf("%d", &n);//输⼊要查找的数int m=f(n, arr, 10-1);if(f(n, arr, 10-1)!=-1)printf("该数所在下标为：%d\n", m);elseprintf("该数不存在\n");}int f(int n, int a[], int h){int i, l, mid;l = 0;while(l<=h)//注意有等号,因为可能最后⼀次查找就只剩⼀个数,则这时上下限下标相等{mid=(l+h)/2;//计算中间下标if(a[mid]==n)//判断是否为⽬标数return mid;else if(a[mid]<n)l=mid+1;//如果中间数⼩于⽬标数,则将数组下限改为较⼤半区的下限elseh=mid-1;//如果中间数⼤于⽬标数,则将数组上限改为较⼩半区的上限}return -1;//返回-1表⽰⽬标数不存在}。
【C语言】乱序整数列快速排序二分查找【原创技术】
实验内容对乱序整数序列，先用快速排序按非减序排列，再进行二分查找，查找某个元素是否存在，若存在返回匹配的第一个下标位置（从0开始），不存在返回-1。
示例输入（第一行表示要查找的数，第二行以后表示数组元素，为编程方便，可限定为20个数，也可不限，自动分配空间）：9556877895412351110245678212442455687945576230示例输出（只输出数值即可，不许其他文字）：-1提示：分治法快速排序第一步：分解以aq为基准元素将ap:r划分成3段ap:q-1、aq和aq+1:r，使得ap:q-1中任何元素小于aq ，aq+1:r中任何元素大于aq ；下标q在划分过程中确定。
第二步：递归求解递归调用快速排序算法对ap:q-1和aq+1:r进行排序；第三步：合并对ap:q-1和aq+1:r的排序是就地进行的，ap:q-1和aq+1:r排好序后不需要执行任何计算，ap:r就已排好序。
源代码：//快速排序 + 二分查找#include <stdio.h>int Partition(int a[],int p,int r) //对20个数进行划分，划分后进行快速排序{int i=p,j=r+1;int x=a[p];while(1){while(a[++i]<x && i<r);while(a[--j]>x);if(i>=j) break;int temp; //交换两个数的值temp=a[j];a[j]=a;a=temp;}a[p]=a[j];a[j]=x;return j;}void QuickSort(int a[],int p,int r) //进行快速排序{if(p<r){int q=Partition(a,p,r);QuickSort(a,p,q-1);QuickSort(a,q+1,r);}int HalfSearch(int a[],int n,int goal) //定义二分查找函数{int high=n-1,low=0,middle;while (high>=low){middle=(high+low)/2;if(goal<a[middle]) high=middle-1;else if(goal>a[middle]) low=middle+1;else{return middle;}}return -1;}int main(){int i,goal,a[20];scanf("%d",&goal); //输入你要查找的数for (i=0;i<20;i++)scanf("%d",&a); //输入20个数QuickSort(a,0,19); //调用快速排序函数，多20个数进行排序int search=HalfSearch(a,20,goal); //调用二分查找函数printf("%d\n",search); //输出你要查找的数的情况return 0;}运行过程截图：源代码下载：BinarySearch.cpp(1.28 KB, 下载次数: 0)【C语言】分治法合并排序【原创技术】：去学习文章出处: /forum.php?mod=viewthread&tid=1489。
二分查找法C语言立体7-6
二分查找法C语言立体7-6
二分查找法的算法步骤描述如下：设n个元素的数组a已升序排列，用left和right两个变量来表示查找的区间，即在a[left] 〜 a[right]区间去查找x。
初始状态为left = 0，right = n-1。
首先用要查找的x与查找区间的中间位置元素a[mid]（mid = (left + right) / 2）比较，如果相等则找到；如果x < a[mid]，由于数组是升序排列的，则只要在a[left] 〜 a[mid-1]区间继续查找；如果x > a[mid]，则只要在a[mid+1] 〜 a[right]区间继续查找。
也就是根据与中间元素比较的情况产生了新的区间值left、right值，当出现left > right时，说明不存在值为x的元素。
输入格式：输入在第1行中给出一个正整数n（1≤n≤10）和一个整数x，第2行输入n个整数，其间以空格分隔。
题目保证数据不超过长整型整数的范围。
输出格式：在每一行中输出查找过程中对应步骤的中间结果，按照“[left,right][mid]”的格式输出。
提示：相邻数字、符号之间没有空格。
算法-二分法查找
算法-⼆分法查找什么是⼆分法查找⼆分法查找主要是为了快速查找给定数组内，期待值在数组中的位置（下标）⼆分法查找通过对整个数组取中间值，判断期待值所在的范围并缩⼩范围，每次查找范围折半，直到范围的边界重合，得出期待值的位置，如果找不到返回null⼆分法有⼀个先决条件是：数组内元素必须是有序的简单图解给定⼀个包含1，3，5，7，8，9这⼀个元素的有序数组，求得期待值7所在的位置，下边⽤绿块表⽰指针所在位置若是按照直接遍历的⽅式，绿块会从数组的第⼀个下标开始⽐较，直到7所在的下标得到结果，遍历需要4次，下边演⽰下⼆分法的图⽰第⼀次，取值范围为整个数组，取数组长度中间值(0+5)/2取整2作为下标取中间值初始以数组的第⼀个下标与最后⼀个下标相加取中间值，如果不为整，舍去⼩数部分⽐较期待值与下标为2的值⼤⼩，发现5<7，7这个值应在中间值的右侧缩⼩查找范围为中间值+1与最⼤下标第⼆次，范围缩⼩为原数组的⼀半，下标不变，取中间值(3+5)/2=4下标4对应的值8，⼤于7，所以向左取范围最⼩下标3，最⼤下标4-1=3第三次，取中间值(3+3)/2=3，下标3上的值恰好与期待值相等，返回下标3虽然看起来只少了⼀次，原因在数组的长度⼩，另外就是期待值设置的⼩，再举个长⼀点的例⼦，这⾥有1-100的数组，100个元素，期待值为100简单遍历次数最⼤为元素的个数n次，本例中100次使⽤⼆分查找只需要log2n次，本例中7次！⼆分法查找的Java实现package binarysearch;/*** ⼆分查找：求得期待值在有序数组中的位置* @author hellxz*/public class MyBinarySearch {/*** ⼆分查找算法实现* @param orderedArray 有序数组* @param expect 期待数值* @return 期待值在数组中的下标，如果期待数值不在数组中，返回null*/public static Integer binarySearch(int[] orderedArray, int expect) {//low与high构成动态的数组下标范围//初始low下标为0，high为数组长度-1int low = 0;int high = orderedArray.length - 1;//当数组范围存在时，有两种情况：最⼩边界值⼩于最⼤边界值或两个边界值相等；//最⼩边界值不⼤于最⼤边界值是有意义的，表⽰范围的存在，如果范围不存在了，说明数组中⽆此元素while (low <= high) {//取两个边界下标的中间下标与中间值，作为下标时会⾃动取整int middle = (low + high) / 2;int middleVal = orderedArray[middle];//中间值与期待值相等，说明中间值的下标就是我们要找的期待数的下标if (middleVal == expect) {return middle;}//中间值⼩于期待值，我们需要将最⼩边界下标移到中间下标的下⼀位//此时，最⼤边界不变，最⼩边界变⼤，范围缩⼩原来⼀半if (middleVal < expect) {low = middle + 1;}//中间值⼤于期待值，说明最⼤边界应⼩于中间下标if (middleVal > expect) {high = middle - 1;}}//循环结束未返回下标说明数组中不存在期待元素，返回nullreturn null;}public static void main(String[] args) {int[] arr = { 2, 4, 5, 6, 10, 18, 19,22, 25, 70};int expectVal = 25;System.out.printf("当前期待的值为%d，其所在的下标为%d", expectVal, binarySearch(arr, expectVal));}}最后本⼈不是科班出⾝，很多知识都在学习中，算法与数据结构系列将不定时更新（学会哪个更哪个 ）。
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;}运⾏结果如下：希望对您有所帮助！以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
C语言二分查找算法
C语言实现二分查找算法1.1/*二分算法*/#include<stdio.h>#define N 100int Found(int a[],int x,int y){int h,r,m;h=0;r=y-1;m=(h+r)/2;while(h<=r&&x!=a[m])if(x<a[m]) {r=m-1;m=(h+r)/2;}else {h=m+1;m=(h+r)/2;}if(h>r) return -1; /*查找失败，返回－1*/return m; /*查找成功，返回有效下标m */} // Search_Binvoid main(){int m,a[N],i,x,n;printf("请输入m=:\n");scanf("%d",&m);printf(" 请按从小到大的顺序输入一组数:\n");for(i=0;i<m;i++)scanf("%d",&a[i]);printf("请输入要查找的数:\n");scanf("%d",&x);n=Found(a,x,m);if(n==-1)printf("查找失败");elseprintf("\n位置是%d\n",n);}1.2#include <stdio.h>#include <stdlib.h>typedef int DATATYPE; /*假定顺序表元素的类型为整型*/#define maxsize 1024 /*假定顺序表的最大长度为1024*/typedef struct{DATATYPE data[maxsize]; /*顺序表元素数组，第一个结点是data[0] */ int len; /*线性表中实际存放的数据个数*/} SEQLIST;/******************************************************************** *********/void ListInit (SEQLIST *L)//将表L清空(初始化）{L->len=0;}/******************************************************************** *********/int ListLength(SEQLIST L)//返回线性表L的元素个数{return(L.len);}int ListInsert(SEQLIST *L, int i, DATATYPE x)//在顺序表L的第i个位置插入元素x，成功：1，失败：0{int j;if ((L->len)>=maxsize){printf("overflow\n");return 0;} //溢出elseif((i<1)||(i>L->len+1)){printf("error\n");return 0;} //非法位置else{for(j=L->len-1;j>=i-1;j--)L->data[j+1]=L->data[j]; //结点后移L->data[i-1]=x; //插入xL->len=L->len+1; //表长加1return(1); //成功}}void Listinput(SEQLIST *L,DATATYPE x){int i,n;printf("请输入要输入的数据个数：");scanf("%d",&n);for(i=0;i<n;i++){printf("请输入第%d个数据：",i+1);scanf("%d",&(L->data[i]));L->len++;}printf("输入成功！！");}int Listsearch(SEQLIST *L,DATATYPE K){ int low=0,mid,high=L->len-1;while (low<=high){ mid=(low+high)/2; //整除if (K==L->data[mid])return mid;if (K<L->data[mid])high=mid-1;else low=mid+1;}return -1; //查找失败}main(){SEQLIST list;int i,xuanze,p;DATATYPE x;char flag='Y';ListInit (&list);while(1){printf(" 1、创建顺序表数组\n");printf(" 2、查找数据\n");printf(" 0、退出\n");printf("\n");printf("请选择:");scanf("%d",&xuanze);switch(xuanze){case 1:{Listinput(&list,x);break;}case 2:{while(toupper(flag)=='Y'){printf("\n请输入要查找的数据:");scanf("%d",&p);Listsearch(&list,p);if(Listsearch(&list,p)==-1)printf("查找失败!!\n");else printf("查找成功!!\n");printf("是否继续查找(y/n):");scanf("%s",&flag);}break;}case 0:{return ;break;}default:{printf("谢谢使用！！");break;}}system("cls");}}。
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查找成功在上⾯的代码中，我们成功地通过⼆分査找算法实现了查找功能，其实现过程如下图所⽰。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
电子实习报告
这次电子实习的目的是为了提高我们的编程能力，与上次的电工实习一样重要，要成为一名合格的大学本科毕业生，这是一个不可或缺的环节，所以我们要把握好这次机会，全力以赴，做到更好。
（一）需求分析
这次实习，每个同学的题目都不一样，这才能考验学生的水平嘛，我的题目是：编写二分法查找法的图形演示程序，用箭头跟踪指示出二分查找过程中的查找位置。
当我刚拿到题目的时候，顿时吃了一惊，这也太难了，让我用二分法查找一个数还说的过去，那个我们学过，可是要用箭头跟踪指示出来可就让我大伤脑筋，用C语言绘图我们压根就没学过，我还想跟指导老师好好商量商量，让她多给点提示，可是仔细一想，要是我学过，这两个星期都花上面都不合算，这也就是实习的目的所在啊，就的现学现用，顺便培养一下我们的自学能力，真是一箭双雕啊。
接着，还是在指导老师的指点下，我先去图书馆找找相关的资料，用是碰钉子了，C语言这方面的书是少之又少，而且也是盲目的在那翻阅，见与绘图有关的书都翻翻，还是没有头绪，最后借了本C语言精彩编程。
接着我又借了一本C图象处理编程，只有这两本书的紧密结合才能编出我那程序。
首先我的想法是只在Borland C++这个环境下完成，先把头绪给理清一遍，从我这题目中可以看到，要编出来主要有两大步：二分法和跟踪箭头。
这二分法查找要求被查找的数据是按照某种顺序排列的有序序列，因此应该先将数据排序，再用二分法查找要查找的数据。
二分法查找又称折半查找，是一种效率高的
有序顺序表上的查找方法，下面讨论一下二分查找的实现方法：设顺序表存储在一维数组S中，设置三个变量low,high和mid，它们分别指向当前查找范围的下界，上界和中间位置。
初始化时，令low=0,high=n-1,设置待查找数据元素的关键字为key.
(1)mid=[low+high/2].
(2)比较Key与s[mid].key值的大小，若s[mid].key= Key，则查找成
功，结束查找，若s[mid].key〈Key，表明关键字为Key的记录可
能在于记录s[mid]的后半部分，修改查找范围，令下界指示变量low=
mid+1，上界指示变量high的值保持不变。
若s[mid].key〉Key，
表明关键字为Key的记录只可能存在于s[mid]的前半部，修改查找
范围，令high = mid-1，变量low保持不变。
(3)当前变量low与high的值，若low 〈=high，重复执行第（1）步
和第（2）步，若low 〉high，表明整个表已经查找完毕，表中不村
在关键字为的Key记录。
当然这里边也用到了冒泡排序法，所谓的冒泡排序就是指按增加或减少的顺序对一组类似的信息重新进行安排的过程。
一般来说，当对信息进行排序时，只有信息中的某一小部分被用作排序的关键字，根据关键字对各元素进行比较。
当必须要进行比较时，彼此交换的则是整个元素。
以上是对数据的查找方法的分析，下面就具体说说跟踪箭头的问题：
对于这个箭头也就是光标了，这用到了C语言的图象处理，有对光标的控制程序和显示程序。
光标的显示是动态图象，即一个移动的图象在屏幕上
的运动，它到某处就遮盖掉部分背景，当再移到别处时原来被覆盖的内容应该被恢复，否则画面要被移动的图象所破坏。
动态显示一般由下列4个步骤组成：
（1）图符与背景的异或来实现。
第1次异或显示光标，第2次异或恢复背景。
16色图形显示中的光标通常采用次法，WINDOWS图形编程中
还时常采用这种方法。
（2）存储背景参数（字符`图象名称等），恢复时再重新生成。
文字画面或下拉式菜单等通常采用此法。
DOS环境下的字处理软件常采用这种方
法。
（3）用存储背景图象像素数据的方法来实现。
用get_image()子程序保存背景的图象数据，以后用put_image()子程序恢复数据。
复杂的图象
画面通常采用的方法。
（二）程序设计
本程序用到好几种数据类型，有整型，结构体，字符型
主函数的流程图如下：
调用二分法查找函数binarysearch
结束
这就是主函数的流程图。
（三）调试分析
在运行过程中，就是刚开始接触Turboc的时候很不了解，因为这那环境下，鼠标不能用，只能用键盘操作。
（1）编好的文件也不知道怎么在Turboc下打开，摸索后才发现可以在load中打开，不过的先把文件放在Turboc文件下。
（2）这也是调试时出现的错误，本以为程序应该没多大问题了，可出来五个错误，真让我束手无策，同样也是经过许久才找到问题所在，没改路径，所以有好多文件就找不找。
这就是那个没修改路径出来错误的界面。
出现这些错误都是因为我对那个Turboc环境不熟悉。
在运行中也遇到问题，比如说，如果我查找的范围稍微大点，结果可能就看不到，因为设置的时候就出了点问题。
这个问题后来也解决了，改进了
一下程序，将运行的演示过程切换到另下一个屏幕，所以数据再多也可以显示。
（四）使用方法
本程序是为了用二分法查找法的图形演示，可以有箭头跟踪指示出二分查找过程中的位置。
使用方法如下几步：
1．进入turboc或VC界面下，打开文件ERFENFA.C，在去OPTION —》DIRECTION中修改路径。
2．CTRL+F9运行程序。
3．运行界面会提示：Please input the stall number:用户就可以输入你要从几个数中查找，但不超过二十个（这是程序设计），输完敲回车。
4．运行界面会提示：Please input yours numbers:用户可以输入你那些数据，输完敲回车。
5．运行界面会提示：Please input the key number:用户应该输入你要查找的那个数，当然这个数必须是你上面数据中的一个，输完敲回
车。
6．你就可以看到查找的整个演示过程。
以上六步就是对本程序的使用步骤。
（五）测试结果
1）测试数据
Please input the stall number(<=20):11（要查找的总数）
Please input the 1 number:1
Please input the 2 number:2
Please input the 3 number:3
Please input the 4 number:4
Please input the 5 number:5 （列出所有数据）
Please input the 6 number:6
Please input the 7 number:7
Please input the 8 number:8
Please input the 9 number:9
Please input the 10 number:0
Please input the 11 number:98
Please input the key number:1 （要查找的数）
2）测试结果
没找到能拷贝的方式
（六）注释原代码
#include"stdio.h"
#include"graphics.h"
#include"conio.h"
#define maxsize 20
typedef struct
{int key;int dress[2]; //保存数据key在屏幕上显示的位置}st; //定义结构体
typedef struct。