c语言二分查找递归算法

⑴ 编写一个在有序表中二分查找给定关键字记录的递归算法 (C语言)

其实这个书本上可以找到的，逻辑也比较容易实现。我写一下主要的逻辑吧。
int Serch(int * a, int low, int high. int key)
{
if (low <= high)
{

int mid = ( high - low) / 2 + low;
if (key == a[mid]) // 找到了

return mid;
else if (key < a[mid]) // 比中间值小，向前找

Serch(a, low, mid - 1, key);
else // 向后找

Serch(a, mid + 1, high, key);

}
return -1; // 没找到

}

⑵ C语言 二分法查找 排序问题

a.txt:读入数据

b.txt: 写入排序数据

c.txt: 写入查找结果

#include<stdio.h>

constintmaxn=1000;
intnum[maxn],n;


voidswap(int*x,int*y){
*x^=*y;
*y=*x^*y;
*x=*x^*y;
}

voidfinput(){
printf("--------
readdatafroma.txt
--------

");
FILE*fin=fopen("a.txt","r");
n=0;
while(fscanf(fin,"%d",&num[n])!=EOF){
n++;
}
fclose(fin);
}


voidbubble(){
printf("--------
startbubblingsortalgorithm
");
for(inti=n-1;i>0;--i){
for(intj=0;j<i;++j){
if(num[j]>num[j+1]){
swap(&num[j],&num[j+1]);
}
}
}

printf("writetheresultofsortinb.txt
--------

");
FILE*fout=fopen("b.txt","w");
for(inti=0;i<n;++i){
fprintf(fout,"%d
",num[i]);
}
fclose(fout);
}

intrbesearch(intlow,inthigh,intv){
//recursivebinarysearch
//returntheindexofv.ifnotexists,return-1.
if(low==high){
if(num[low]==v)returnlow;
return-1;
}
if(num[low]==v)returnlow;
intmid=(low+high)/2;
if(num[mid]<v){
returnrbesearch(mid+1,high,v);
}
else{
returnrbesearch(low,mid,v);
}
}

intnrbesearch(intlow,inthigh,intv){
//non-recursivebinarysearch
//returntheindexofv.ifnotexists,return-1.
while(low<high){
intmid=(low+high)/2;
if(num[mid]<v){
low=mid+1;
}
else{
high=mid;
}
}
if(low==high&&num[low]==v){
returnlow;
}
return-1;
}


voidsearch(){
printf("--------
");
printf("Startsearch.
");
printf("Theresultswillbewritteninc.txt
");
printf("pleaseinputanum.ifnum=-123456,quit.
");

FILE*file=fopen("c.txt","w");
while(true){
intv;
scanf("%d",&v);
if(v==-123456)break;

intrb=rbesearch(0,n-1,v);
intnrb=nrbesearch(0,n-1,v);

fprintf(file,"input:%d
",v);
fprintf(file,":%d
",rb);
fprintf(file,"theresultofnon-recursivebinarysearch:%d

",nrb);

printf(":%d
",rb);
printf("theresultofnon-recursivebinarysearch:%d

",nrb);
}
fclose(file);

}

intmain(){
finput();
bubble();
search();
return0;
}

⑶ 用递归方法写出有序数组的二分查找算法

什么是二分查找？

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

二分查找优缺点

优点是比较次数少，查找速度快，平均性能好；

其缺点是要求待查表为有序表，且插入删除困难。

因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
使用条件：查找序列是顺序结构，有序。

过程

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

利用循环的方式实现二分法查找

public class BinarySearch {
public static void main(String[] args) {
// 生成一个随机数组 int[] array = suiji();
// 对随机数组排序 Arrays.sort(array);
System.out.println("产生的随机数组为： " + Arrays.toString(array));

System.out.println("要进行查找的值： ");
Scanner input = new Scanner(System.in);
// 进行查找的目标值 int aim = input.nextInt();

// 使用二分法查找 int index = binarySearch(array, aim);
System.out.println("查找的值的索引位置： " + index);

}

/** * 生成一个随机数组 *
* @return 返回值，返回一个随机数组 */
private static int[] suiji() {
// random.nextInt(n)+m 返回m到m+n-1之间的随机数 int n = new Random().nextInt(6) + 5;
int[] array = new int[n];
// 循环遍历为数组赋值 for (int i = 0; i < array.length; i++) {
array[i] = new Random().nextInt(100);
}
return array;
}

/** * 二分法查找 ---循环的方式实现 *
* @param array 要查找的数组 * @param aim 要查找的值 * @return 返回值，成功返回索引，失败返回-1 */
private static int binarySearch(int[] array, int aim) {
// 数组最小索引值 int left = 0;
// 数组最大索引值 int right = array.length - 1;
int mid;
while (left <= right) {
mid = (left + right) / 2;
// 若查找数值比中间值小，则以整个查找范围的前半部分作为新的查找范围 if (aim < array[mid]) {
right = mid - 1;
// 若查找数值比中间值大，则以整个查找范围的后半部分作为新的查找范围 } else if (aim > array[mid]) {
left = mid + 1;
// 若查找数据与中间元素值正好相等，则放回中间元素值的索引 } else {
return mid;
}
}
return -1;
}}
运行结果演示：

总结：

递归相较于循环，代码比较简洁，但是时间和空间消耗比较大，效率低。在实际的学习与工作中，根据情况选择使用。通常我们如果使用循环实现代码只要不是太繁琐都选择循环的方式实现~

⑷ 求二分法查找演示C语言源代码

二分法查找算法：

1.主要思想是：假设数据是按升序排序的，对于给定值x，从序列的中间位置开始比较，如果当前位置值等于x，则查找成功；若x小于当前位置值，则在数列的前半段 中查找；若x大于当前位置值则在数列的后半段中继续查找，直到找到为止。

2. 时间复杂度: O(log2n)。

3. C语言源代码(小例子）

search函数即为核心代码：递归查找

#include<stdio.h>
intsearch(int*a,intnum,intlow,inthigh)
{
	intmid=(low+high)/2;
	if(low<=high)
	{
		if(num<a[mid])
			returnsearch(a,num,low,mid-1);//加return
		if(num>a[mid])
			returnsearch(a,num,mid+1,high);//加return
		if(num==a[mid])
			return1;
	}
	else
		return0;
}
intmain(){
	inta[11]={0,1,2,3,4,5,9,11,12,13,15};
	if(search(a,11,0,10)==1)
		printf("success!!");
	else
		printf("failed!!");
}

⑸ 用C语言编写非递归算法实现折半查找（二分查找）

char
a[10][5];//按字典序递增
int
search(char
*x)//二分查找，返回有序表中大于等于x的元素位置
{
int
low=0,high=9,mid,t;
while(low<=high)
{
mid=(low+high)/2;
t=strcmp(a[mid],x);//比较中点位置与x
if(t==0)
return
mid;//相等返回其位置
else
if(t>0)
high=mid-1;//x小于mid元素，则在中点前
else
low=mid+1;
}
return
high+1;//返回大于x的第一个元素
}
这个是我曾经用过的字符串的二分查找~
请根据需要修改数据类型。。。

⑹ C语言折半查找之递归算法

T的elem没初始化，没有申请内存空间。
而且Create的参数T必须要用引用传递，不然main中执行完Create(T,a)后，T的值不会变化 。

void Create(SSTable &T,int a[]){
int j;
T.elem=new ch[len(a)];
for(j=1;j<len(a)+1;j++)T.elem[j].key=a[j];
T.length=len(a);
}

⑺ 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;
}