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

}