分治法二分搜索算法c语言

❶ 用c语言编二分查找

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void xuanzhe(int a[], int n)
{
int i, j, min, t;

for (i=0; i<n-1; i++) /*要选择的次数：0~n-2共n-1次*/
{
min = i; /*假设当前下标为i的数最小，比较后再调整*/
for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/
{
if (a[j] < a[min])
{
min = j; /*如果后面的数比前面的小，则记下它的下标*/
}
}

if (min != i) /*如果min在循环中改变了，就需要交换数据*/
{
t = a[i];
a[i] = a[min];
a[min] = t;
}
}
}
int main(){
int i,n,x;
int mid,left=0,right=999;
int find1=0,find2=0;
double y;
int a[1000];
for(i=0;i<1000;++i){
a[i]=rand();
}
xuanzhe(a,1000);
scanf("%d",&x);
printf("顺序查找:\n");
for(i=0;i<1000;++i){
while(x==a[i]){
printf("找到X=%d,a[%d]\n",x,i);
find1=1;
break;
}
}
if(find1==0){
printf("没有你要找的数\n");
}

printf("%fs\n",clock()/CLOCKS_PER_SEC);
y=clock();
printf("二分查找:\n");
while(!find2&&left<right)
{
mid=(left+right)/2;
if(x==a[mid])
find2=1;
else if(x<a[mid])
right=mid-1;
else left=mid+1;
}
if(find2==1)
printf("找到x=%d ,a[%d]\n",x,mid);
else
printf("没有你要找的数\n");
printf("%fs\n",(clock()-y)/CLOCKS_PER_SEC);
}

❷ 一道C语言的题目 二分查找算法和插入元素

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// 定义数组初始长度
#define LEN 10
// 生成随机数组
void get_array(int * a, int n)
{
srand(time(NULL));
for (int i = 0; i < n; i++)
a[i] = rand() % 90 + 10;
}

// 打印数组
void print_array(int * a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf(" ");
}

// 冒泡排序
void bubble_sort(int * a, int n)
{
int i, j, temp;
for (j = 0; j < n - 1; j++)
{
for (i = 0; i < n - 1 - j; i++)
{
if(a[i] < a[i + 1])
{
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
}
}
}
}

// 二分查找，a是数组,n是数组长度,element是要查找的元素
// 找到返回元素所在的下标,否则返回-1
int binary_search(int * a, int n, int element)
{
int low = 0, high = n - 1, middle = 0;
middle = (low + high) / 2;
int pos = -1;
while (low <= high)
{
if (element == a[middle])
return pos = middle;
else if (element > a[middle])
{
high = middle - 1;
middle = (low + high) / 2;
}
else
{
low = middle + 1;
middle = (low + high) / 2;
}
}
return pos;
}

// 向长度为n的数组a中插入元素element
void insert(int * a , int n, int element)
{
a = (int *)realloc(a, n + 1);

for (int i = 0; i <= n; i++)
{
if (a[i] > element)
continue;
for (int j = n; j > i; j--)
{
a[j] = a[j-1];
}
a[i] = element;
break;
}
}

// 测试
int main()
{
int *array = (int *)malloc(LEN);
if (NULL == array)
{
printf("内存分配失败 ");
return -1;
}
int element = 0;
get_array(array, LEN);
printf("生成的随机数组: ");
print_array(array, LEN);
bubble_sort(array, LEN);
printf("排序后的数组: ");
print_array(array, LEN);

printf("请输入查找的元素: ");
scanf("%d", &element);
int pos = binary_search(array, LEN, element);
if (-1 == pos)
{
printf("未找到元素[%d] ", element);
insert(array, LEN, element);
printf("插入新元素[%d]后的数组: ", element);
print_array(array, LEN + 1);
}
else
printf("元素[%d]所在的位置为[%d] ", element, pos);

free(array);
return 0;
}

❸ c语言 最快的查找方式

1、最快的查找方式是：二分法查找。
2、查找的线性表分：无序线性表、有序线性表、分块有序线性表。
3、对无序线性表只能采用顺序查找，顺序查找的平均比较次数为（n+1)/2
4、对有序线性表可以采用二分查找，二分查找的比较次数为log2n
5、对分块有序线性表可以采用分块法查找。

C语言是一种计算机程序设计语言，它既具有高级语言的特点，又具有汇编语言的特点。它由美国贝尔研究所的D.M.Ritchie于1972年推出，1978年后，C语言已先后被移植到大、中、小及微型机上，它可以作为工作系统设计语言，编写系统应用程序，也可以作为应用程序设计语言，编写不依赖计算机硬件的应用程序。它的应用范围广泛，具备很强的数据处理能力，不仅仅是在软件开发上，而且各类科研都需要用到C语言，适于编写系统软件，三维，二维图形和动画，具体应用比如单片机以及嵌入式系统开发。

❹ C语言 二分查找算法 用递归实现 我改动了一下

本人直接打出来的，并未在平台上编译运行过，所以可能会有语法错位，还请自行调试更改
#include<stdio.h>

int RecorBinarySearch(int a[], int, int, int);
int main(void)
{
int i=0, n, m, key;
int a[10000], c[10000];

scanf("%d", &n);
scanf("%d", &m);

printf("提示：输入%d个整数且必须按升序排列。\n", n);
for(i=0; i<n; i++){
scanf("%d", &a[i]);
}
printf("提示：输入%d个预查找的数。\n", m);
for(i=0; i<m; i++){
scanf("%d", &key);
c[i] = RecorBinarySearch(a, key, 0, n-1);
}
printf("提示：输出预查找的数在数组中的位置。（-1代表未找到）\n");
for(i=0; i<m; i++) {
printf("%d ", c[i]);
}
return 0;
}

int RecorBinarySearch(int a[], int key, int low, int high)
{
int nRet;
if(low > high)
nRet = -1;
else {
int mid = (high + low) / 2;
if(key == a[mid])
nRet = mid;
else if(key > a[mid])
nRet = RecorBinarySearch(a, key, mid+1, high);
else if(key < a[mid])
nRet = RecorBinarySearch(a, key, low, mid-1);
}
return nRet;
}

❺ 二分搜索算法

#include <stdio.h>

#include <stdlib.h>

int a[100]={1,2,3,5,12,12,12,15,29,55};//数组中的数（由小到大）

int k;

void found(int &x,int &y,int k) //在x与y之间，要找k

{

if(x>y)return;

int m=x+(y-x)/2;

if(a[m]==k)x=y=m;

else if(a[m]>k)found(x,y=m-1,k);//找左边

else found(x=m+1,y,k);//找右边

}

int main()

{ int i=0,j=9;

scanf("%d",&k);//输入要找的数字k

found(i,j,k);//从数组a[0]到a[9]中找k

if(i==j)printf("a[%d]==%d ",i,k);

else printf("a[%d]==%d a[%d]==%d, k==%d ",j,a[j],i,a[i],k);

return 0;

}

❻ c语言编程二分查找

好久不写了

写一个程序，建立N元整型数组，然后输入查找的整数x，查找x是否包含在数组中，查找用函数实现，若查找成功，返回x在数组中的第一次出现的下标，查找失败，返回－1

源程序：
#include"stdio.h"
#define N 10
int locate(int a[N],int x)
{int h,r,m;
h=0;r=N-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 */
}
void upinsert(int a[],int i) /*插入排序 （升序）*/
{int x,j;
x=a[i];j=i-1;
while(j>=0&&a[j]>x) {a[j+1]=a[j];j--;}
a[j+1]=x;
}
void main()
{int a[N],x,k,n;
printf("input %d integers:\n",N);
for(k=0;k<N;k++) {scanf("%d",a+k);upinsert(a,k);}
printf("input x=") ;scanf("%d",&x);
n=locate(a,x);
for(k=0;k<N;k++) printf("%4d",a[k]);
printf("\n fist position=%d\n",n);
}

没有错误，我试过了

❼ C语言问题求解，二分查找

二分查找也称折半查找，它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

#include <stdio.h>

int cnt;

int binfind(int a[],int l,int r,int x)

{ cnt++;

int m=(l+r)/2;

if(l>m)return -1;

if(x==a[m])return m;

if(x>a[m])return binfind(a,m+1,r,x);

return binfind(a,l,m-1,x);

}

int main()

{ int n,i,x,a[100];

scanf("%d",&n);

for(i=0; i<n; i++)

scanf("%d",&a[i]);

scanf("%d",&x);

i=binfind(a,0,n-1,x);

printf("%d %d ",i,cnt);

return 0;

}

❽ C语言递归函数如何实现二分搜索算法

折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是，已知一个有n个元素的有序序列, 将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。如果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。如果x>a[n/2]，则我们只要在数组a的右半部继续搜索x, 直到找到x或者是没有找到!

如果是常规的方法的话那么我们可以通过循环的方式, 按照上面说的算法, 找到则退出循环, 否则继续循环直到左下标位置小于或者等于右下标的位置.

按兄弟你的意思是要用递归方法进行搜索, 那么大概还是上面的算法, 只是把循环的方式改成递归方式: 如果没找到,则确定新的搜索范围, 即左右下标新位置, 然后把新的参数传给函数继续调用函数进行递归搜索!!

递归方式实现详细代码如下:

#include <stdio.h>

#define ARRAY_SIZE 10
#define NOT_FOUND -1

int BinarySearch(int array[], int left, int right, int NumToSearch)
{
int mid = (left + right) / 2;

if (left <= right)
{
if (NumToSearch == array[mid])
{
return mid;
}
else if (NumToSearch < array[mid])
{
right = mid - 1;
return BinarySearch(array, left, right, NumToSearch);
}
else
{
left = mid + 1;
return BinarySearch(array, left, right, NumToSearch);
}
}

return NOT_FOUND;
}

int main()
{
int a[ARRAY_SIZE] = {2, 5, 6, 7, 13, 20, 22, 27, 112, 222};//假设一个已知的有序且是升序数列
int result = 0;//查找的结果
int x = 13;//假设我们要查找的数是13
int left = 0;//序列开始下标
int right = ARRAY_SIZE - 1;//序列结尾下标

result = BinarySearch(a, left, right, x);
if (result == NOT_FOUND)
{
printf("Not Found!\n");
}
else
{
printf("Found %d in array a, it is a[%d]\n", x, result);
}

return 0;

}

希望对兄弟你有帮助!

❾ 怎样写二分查找算法的程序（用C语言实现）

我用一个子函数实现的，主函数你自己写，对你又好处，需要传入一个数组和数组长度n以及要查找的数,如果查找成功，返回x在数组中的位置，否则返回-1
int search(int *a,int x)
{ int low=0,high=n-1,mid,flag=-1;
while(low<=high)
{ mid=(low+high)/2;
if(a[mid]==x) return mid;
else if(a[mid]>low) low=mid+1;
else high=mid-1;
}
return flag;
}

❿ 用C语言编写顺序查找和二分查找（折半查找）

#include<stdio.h>
#defineLENGTH20

voidSequenceSearch(int*fp,intLength);
voidSearch(int*fp,intlength);
voidSort(int*fp,intlength);

voidmain()
{
intcount;
intarr[LENGTH];

printf("请输入你的数据的个数:
");
scanf("%d",&count);
printf("请输入%d个数据
",count);
for(inti=0;i<count;i++)
{
scanf("%d",&arr[i]);
}

intchoise=0;
do
{
printf("1.使用顺序查询.
2.使用二分查找法查找.
3.退出
");
scanf("%d",&choise);

if(choise==1)
SequenceSearch(arr,count);
elseif(choise==2)
Search(arr,count);
elseif(choise==3)
break;
}while(choise==1||choise==2||choise==3);
}

voidSequenceSearch(int*fp,intLength)
{
intdata;
printf("开始使用顺序查询.
请输入你想要查找的数据.
");
scanf("%d",&data);

for(inti=0;i<Length;i++)
if(fp[i]==data)
{
printf("经过%d次查找，查找到数据%d.
",i+1,data);
return;
}

printf("经过%d次查找，未能查找到数据%d.
",i,data);
}

voidSearch(int*fp,intlength)
{
intdata;
printf("开始使用顺序查询.
请输入你想要查找的数据.
");
scanf("%d",&data);
printf("由于二分查找法要求数据是有序的，现在开始为数组排序.
");
Sort(fp,length);
printf("数组现在已经是从小到大排列,下面将开始查找.
");

intbottom,top,middle;

bottom=0;
top=length;

inti=0;
while(bottom<=top)
{
middle=(bottom+top)/2;
i++;
if(fp[middle]<data)
{
bottom=middle+1;
}
elseif(fp[middle]>data)
{
top=middle-1;
}
else
{
printf("经过%d次查找，查找到数据%d.
",i,data);
return;
}
}
printf("经过%d次查找，未能查找到数据%d.
",i,data);
}

voidSort(int*fp,intlength)
{
printf("现在开始为数组排序，排列结果将是从小到大.
");

inttemp;
for(inti=0;i<length;i++)
for(intj=0;j<length-i-1;j++)
if(fp[j]>fp[j+1])
{
temp=fp[j];
fp[j]=fp[j+1];
fp[j+1]=temp;
}

printf("排序完成!
下面输出排序后的数组:
");
for(intk=0;k<length;k++)
{
printf("%5d",fp[k]);
}
printf("
");

}