c语言通过指针方式实现二分查找

A. 编写无序顺序表顺序查找、有序顺序表顺序查找、二分查找算法。用c语言。高分急求！

int IdxSerch(SeqList A[],IdxType index[],int b,KeyType k,int n) {
//分块查找关键字为k的记录，索引表为
index[0..b-1]
int low=0,high=b-1,mid,i;
int s=n/b; //每块记录个数
while(low<=high)
{
//在索引表中进行二分查找，找到的位置放在low中
mid=(low+high)/2;
if(index[mid].key<k) low=mid+1；
else high=mid-1;
}

if(low<b)
{
//在顺序表中顺序查找
for(i=index[low].link;i<=index[low].link+s-1 && i<n;i++)
if(A[i].key==k) return i;
return -1;
}
return -1;
}

typedef struct node
{
KeyType key;
//结点中的关键字
struct node *lchild,*rchild; //左、右孩子指针
}BsTree;

BsTree *BstSeareh(BsTree *BST,KeyType k ,BsTree **parent)
{
BsTree *p=BST,*q=NULL; //p指向根结点，q指向*p的双亲
while(p!=NULL)
{
if(k==p->key)
{ //查找成功
*parent=q;
return (p);
}
q=p;
if(k<p->key) p=p->lchild；
//在左子树中查找
else p=p->rchild; //在右子树中查找
}
*parent=q;
return (p);
//查找失败，返回空
}

B. C语言二分查找运用指针

1.你以为是传一个数组a[]对吧。其实这里将一个指针p指向这个数组a，这时候p和a是一样的。只是用指针形式比较严谨，这里用a[]也没关系，因为两者是一样的。
2。b[14]
=
{0}，是把整个数组初始化所有元素都为0，注意只有写成0是这样的，如果写成b[14]={1},那么只有b[0]也就是b的第一个元素是1，其它的是任意的
3。输出地内容是传入数组a中值和key一样的元素的下标，如果找不到就返回0。
为什么？这是二分法查找的核心呀。二分法查找的数组必须是排好序的.
比如
1
3
7
8
9
10
15那么
你要搜一个数3,首先就从中间开始搜，那么
比中间这个数大的就会在右边，小的在左边，这样
每次查找都会让区间缩小一半，这就是二分法查找的核心。具体的你可以去搜一下二分查找。这就不再多言了。

C. c语言如何实现二分查找，问题描述看图，我的源代码如下：

#include<stdio.h>
intnumbers[1000001];//全局变量,数组numbers太大,必须放在这里定义
intBsearch(intnumbers[],intleft,intright,intk);
intmain()
{
inti,j,k,m,n;
//数组numbers太大,不能放在main函数里,而要放在函数外定义,
//不然的话,会导致函数堆栈溢出.
//原代码intnumbers[1000001];
//反复读入数字和查找数字的数量
while(scanf("%d%d",&n,&k)!=EOF)
{
//读入给定的数字
for(i=0;i<n;i++)
{
scanf("%d",&numbers[i]);
}
for(j=0;j<k;j++)
{
//读入待查找的数字，
scanf("%d",&m);
//请在下面完成查找读入数字的功能
intret;
ret=Bsearch(numbers,0,n-1,m);
printf("%d",ret);
if(j!=k-1)
{
printf("");
}
}
printf("
");
}
return0;
}

intBsearch(intnumbers[],intleft,intright,intm)
{
intmid;
while(left<=right)//原代码while(left<right)
{
mid=(left+right)/2;
if(numbers[mid]==m)
{
returnmid+1;
}
elseif(numbers[mid]>m)
{
right=mid-1;
}
else
{
left=mid+1;
}
}
return0;
}

D. c语言如何实现-数组排序，二分查找

给定已经排好序的n个元素，现在要在这n个元素中找出一特定元素x。顺序搜索的方法是逐个比较，直至找出元素。二分搜索则利用了元素间的次序关系，可大大提高效率。二分法的基本思想是将n个元素分成个数大致相同的两半，取a[n/2]与x作比较。如果x==a[n/2]，则终止。如果x<a[n/2]，则只需在数组的左半部分继续搜索。如果x>a[n/2]，则只需在右半部分搜索。本题要求利用上一题得到的数组进行顺序查找和二分查找，分别为两种查找方法计时。
#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);
}

E. C语言 指针和函数编程实现折半查找算法

//二分法查找算法
intbinary_search(intarr[],int*top,int*bot,intx){
	if(*bot>=*top){
		intindex=*top+(*bot-*top)/2;
		int*mid=&index;
		
		if(arr[*mid]==x)return*mid;
		if(arr[*mid]>x){//x在左侧
			*mid=*mid-1;
			returnbinary_search(arr,top,mid,x);
		}
		else{//x在右侧
			*mid=*mid+1;
			returnbinary_search(arr,mid,bot,x);
		}
	}

	return-1;
}

voidmain()
{
	inta[10]={1,3,5,7,8,9,12,13,15,17};
	intn=sizeof(a)/sizeof(a[0]),x=13,t=0;

	int*top=&t,*bot=&n;
	*bot=*bot-1;

	intindex=binary_search(a,top,bot,x);

	if(index>=0){
		printf("%d在数组索引为[%d]的位置
",x,index);
	}
	else{
		printf("%d在数组中不存在!
",x);
	}
}

F. c语言用指针从S1字符串中查找字符串S2

#include<stdio.h>
#include<string.h>
int Search(char *s1,char *s2)
{
int i,k;
i=0;
if(strlen(s1)<strlen(s2))
{
return -1;
}
k=0;
while(strlen(s1)>=strlen(s2))
{
if(*(s2+i)==*(s1+k+i))
{
i++;
}
else
{
i=0;
k++;
}
if(*(s2+i)=='/0')
return k;
else if(*(s1+k+i)=='/0')
return -1;
}
}
main()
{
char s1[100],s2[100];
int m;
printf("请输入字符串1:");
gets(s1);
printf("请输入字符串2:");
gets(s2);
m=Search(s1,s2);
if(m==-1)
printf("输出结果:\"%s\"不包含 \"%s\"\n",s1,s2);
else
printf("输出结果:\"%s\"包含\"%s\",位置在第%d个字符处 \n",s1,s2,m);
}

G. 请教用C语言实现单链表的二分查找

单链表上只能单向访问，没法进行二分查找，即使是双链表也是如此
二分查找因为要按位查找，因此用的不是链表，而是顺序表（数组），用链表叫得不偿失

H. c语言中如何在链表内使用二分法查找

对于无序的链表，还是沿着头结点顺序查找比较好。
如果要用二分法查找，则先将该链表进行排序，以下是我用冒泡法对单链表进行的排序：
/*单链表排序(mark=1，降序；mark=0，升序)*/
void SortList(LNode *L,int mark)
{
int i,j,change=TRUE;
ElemType temp;
LNode *p=L->next,*q;
if(p && (p->next)) //如果单链表长度<2,则不用排序
{
for(j=1;j<L->data && change;j++)
{
change=FALSE;
p=L->next;
q=p->next;
for(i=0;i<L->data-j;i++)
{
if((q->data>p->data && mark) || (q->data<p->data && (!mark)))
{
temp=p->data;
p->data=q->data;
q->data=temp;
change=TRUE;
}
p=q;
q=q->next;
}
}
}
printf("排序成功\r\n");
}
/*从链表的第curI个点处开始查找第i个结点，前提:i>curI*/
LNode *GetElem2(LNode *L,int curI,int i)
{
LNode *p=L;
while(p=p->next)
if(i==(++curI)) {
return p;
}
return NULL;
}
/*对排序后的链表进行二分法查找*/
int DichotomyList(LNode *L,ElemType e)
{
LNode *p=L;
int cur=0;//cur用来保存当前的位置结点，避免每次定位结点都从头结点开始
int left=1,right=L->data;//我定义的链表，其头结点的数据域保存着链表的长度
int mid=(left+right)/2;
//SortList(L,0);
while(left<=right && (p=GetElem2(p,cur,mid))->data!=e)
{
if(p->data>e) {cur=0;p=L;right=mid-1;mid=(left+right)/2;}
else {cur=mid;left=mid+1;mid=(left+right)/2;}
}
if(p->data==e) {printf("find node in %d.\r\n",mid);return mid;}
else {printf("find none.\r\n");return 0;}
}
经VC上测度通过

如果你要完整的程序的话，留个邮箱，我发给你

I. 用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("
");

}