查找演算法代碼

❶ 二分查找的代碼怎麼寫

以下是四個二分查找代碼的 Python 實廳鎮喚現：
①在扮凱升序數組中查找第一個>=x的元素的下標，查找右邊界
def binary_search_right_bound_ascending(arr, x):
left, right = 0, len(arr) - 1
while left <= right:
mid = left + (right - left) // 2
if arr[mid] < x:
left = mid + 1
else:
right = mid - 1
if left >= len(arr) or arr[left] != x:
return -1
return left

②在降序數組中查找第一個>=x的元素的下標，查找右邊界
def binary_search_right_bound_descending(arr, x):
left, right = 0, len(arr) - 1
while left <= right:
mid = left + (right - left) // 2
if arr[mid] > x:
left = mid + 1
else:
right = mid - 1
if left >= len(arr) or arr[left] != x:
return -1
return left

③在升序數組中查找第一個<=x的元素的下標，查找右邊界
def binary_search_left_bound_ascending(arr, x):
left, right = 0, len(arr) - 1
while left <= right:
mid = left + (right - left) /旅純/ 2
if arr[mid] > x:
right = mid - 1
else:
left = mid + 1
if right < 0 or arr[right] != x:
return -1
return right

④在降序數組中查找第一個<=x的元素的下標，查找右邊界
def binary_search_left_bound_descending(arr, x):
left, right = 0, len(arr) - 1
while left <= right:
mid = left + (right - left) // 2
if arr[mid] < x:
right = mid - 1
else:
left = mid + 1
if right < 0 or arr[right] != x:
return -1
return right

注意：在所有代碼中，如果找不到符合條件的元素，會返回 -1。

❷ 哈希查找演算法程序

查找演算法
基本要求：
（1）設計一個菜單將實現的查找演算法的名字顯示出來，並提示用戶對查找演算法進行選擇；
（2）分別實現順序查找、二分查找（折半查找）、二叉排序樹、哈希查找；
（3）哈希函數採用除留余數發，解決沖突的方法大家任選擇一種；
（4）二叉排序樹必須實現構建、查找、插入、刪除四個基本操作；
（5）輸出各種排序的結果並進行比較。*/

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 20
typedef struct /*順序結構數據類型*/
h.length++;
h.r[ }
else
if(k<l.r[mid].key) high=mid-1;
else low=mid +1;
}
if(i!=0)
{
printf("l.r[%d].key=%d\n",i,k);
printf("查找成功\n");
}
return ht;
}
void HashSearch(RecordHash ht) /*哈希查找*/
{
int k,i;
page_title("哈希查找");
printf("請輸入要查找的關鍵字:");
scanf("%d",&k);
i=k%13;
if(ht.HashTable[i].key==k)
{
printf("ht.HashTable[%d].key=%d\n",i,k);
printf("查找成功\n");
}
else
{
i=i+1;
for(;i<MAX;i++)
if(ht.HashTable[i].key==k)
{
printf("ht.HashTable[%d].key=%d\n",i,k);
printf("查找成功\n");
break;
}
if(i==MAX) printf("查找失敗\n");
}
return_confirm();
}
void main()
{
RecordList L1,L2;
BSTNode *pt;
RecordHash ht;
int k,i;
printf("\n創建順序查找線性表,輸入0則結束輸入(可不按順序輸入)\n");
L1=creat1();
printf("\n創建二分查找線性表，輸入0則結束輸入(按遞增順序輸入)\n");
L2=creat1();
printf("\n創建二叉排序樹，輸入0則結束輸入\n");
pt=creat2();
printf("\n創建哈希表\n");
ht=creat3();
menu:page_title("請選擇查找方式，輸入0則結束輸入");
printf("順序查找請按1\n二分查找請按2\n二叉排序樹查找請按3\n哈希查找請按4\n推出請按0\n");
switch(getch())
{
case '1':
SeqSearch(L1);
break;
case '2':
Binsrch(L2);
break;
case '3':
page_title("二叉排序樹查找");
printf("請輸入要查找的關鍵字:");
scanf("%d",&k);
SearchBST(pt,k);
break;
case '4':
HashSearch(ht);
break;
case '0':
exit(0);
default :
printf("輸入錯誤，按任意鍵返回");
getch();
}
goto menu;

❸ Java用查找演算法的一段代碼如下： 其中boolean A=false; if(name.equals(arr[i])) 麻煩解釋一下 盡量直白

數組從第一個開始比較，完全相同（當前數組值和輸入值一模一樣）A就賦值為true；不一樣A的值不變

❹ c語言 查找演算法實現

#include

int main() {
int i,x,n,*result = NULL;
int a[10],low,high,mid;

scanf_s("%d",&n);
// 確保輸入的數據是非遞減的
for(i = 0 ; i < n && i < 10 ; i++) {
scanf_s("%d",&a[i]);
}

fflush(stdin); // 如果輸入的數組元素多於10個，則廢棄
scanf_s("%d",&x);

low = 0,high = n - 1;
while(low <= high) {
mid = (low + high) / 2;
if(x == a[mid]) {
result = &a[mid]; // 這里給出的是查找到該元素的指針
break;
}
else if(x < a[mid]) {
high = mid - 1;
}
else {
low = mid + 1;
}
}
if(result != NULL) {
printf("%d\n",*result);
}
else {
printf("no result\n");
}
return 0;
}

❺ C語言編寫數據結構查找演算法

實驗五 查找的實現
一、 實驗目的
1．通過實驗掌握查找的基本概念；
2．掌握順序查找演算法與實現；
3．掌握折半查找演算法與實現。
二、 實驗要求
1． 認真閱讀和掌握本實驗的參考程序。
2． 保存程序的運行結果，並結合程序進行分析。
三、 實驗內容
1、建立一個線性表，對表中數據元素存放的先後次序沒有任何要求。輸入待查數據元素的關鍵字進行查找。為了簡化演算法，數據元素只含一個整型關鍵字欄位，數據元素的其餘數據部分忽略不考慮。建議採用前哨的作用，以提高查找效率。
2、查找表的存儲結構為有序表，輸入待查數據元素的關鍵字利用折半查找方法進行查找。此程序中要求對整型量關鍵字數據的輸入按從小到大排序輸入。
一、順序查找
順序查找代碼：
#include"stdio.h"
#include"stdlib.h"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder[50];
intlength;
}list,*sqlist;
int Createsqlist(sqlist s)
{
inti;
printf("請輸入您要輸入的數據的個數:\n");
scanf("%d",&(s->length));
printf("請輸入您想輸入的%d個數據;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所輸入的數據為:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;
}
int searchsqlist(sqlist s,int k)
{
inti=0;
s->r[s->length].key=k;
while(s->r[i].key!=k)
{

i++;
}
if(i==s->length)
{
printf("該表中沒有您要查找的數據！\n");
return-1;
}
else
returni+1;
}
sqlist Initlist(void)
{
sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;
}
main()
{
intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("請輸入您想要查找的數據的關鍵字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的數據的位置為:\n\n%d\n\n",keyplace);
return2;
}
順序查找的運行結果：
二、折半查找
折半查找代碼：
#include"stdio.h"
#include"stdlib.h"
typedef struct node{
intkey;
}keynode;
typedef struct Node{
keynoder[50];
intlength;
}list,*sqlist;
int Createsqlist(sqlist s)
{
inti;
printf("請輸入您要輸入的數據的個數:\n");
scanf("%d",&(s->length));
printf("請由大到小輸入%d個您想輸入的個數據;\n\n",s->length);
for(i=0;i<s->length;i++)
scanf("%d",&(s->r[i].key));
printf("\n");
printf("您所輸入的數據為:\n\n");
for(i=0;i<s->length;i++)
printf("%-5d",s->r[i].key);
printf("\n\n");
return1;
}
int searchsqlist(sqlist s,int k)
{
intlow,mid,high;
low=0;
high=s->length-1;
while(low<=high)
{
mid=(low+high)/2;
if(s->r[mid].key==k)
returnmid+1;
elseif(s->r[mid].key>k)
high=mid-1;
else
low=mid+1;
}
printf("該表中沒有您要查找的數據!\n");
return-1;
}
sqlist Initlist(void)
{
sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
else
returnNULL;
}
main()
{
intkeyplace,keynum;//
sqlistT;//
T=Initlist();
Createsqlist(T);
printf("請輸入您想要查找的數據的關鍵字:\n\n");
scanf("%d",&keynum);
printf("\n");
keyplace=searchsqlist(T,keynum);
printf("您要查找的數據的位置為:\n\n%d\n\n",keyplace);
return2;
}
折半查找運行結果：
三、實驗總結：
該實驗使用了兩種查找數據的方法（順序查找和折半查找），這兩種方法的不同之處在於查找方式和過程不同，線性表的創建完全相同，程序較短，結果也一目瞭然。

❻ C語言常用演算法中,查找無序數列的演算法有哪些

可以用排序+折半查找 代碼如下，編譯軟體DEV C++通過，要查找多少個數只要頃慶陪改一下宏定義就可以了另外要是再優化可以把排序的演算法改一改#define A 10
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,a[A],j,t,b,min,mid,max,p[A],k;
p[0]=1; p[1]=2; p[2]=3; p[3]=4; p[4]=5; p[5]=6; p[6]=7; p[7]=8; p[8]=9; p[9]=10;
printf("請輸入%d個數\n",A);
for(i=0;i<A;i++)
scanf("差裂%d",&a[i]);
for(i=0;i<A;i++)
for(j=i+1;j<A;j++)
if(a[i]>a[j])
{ t=a[i];
k=p[i];
a[i]=a[j];
p[i]=p[j];
a[i]=t;
p[i]=k;
}
printf("請輸入要查找的數字\n");
scanf("%d",&b);
min=0;
mid=A/2;
max=A-1;
for(i=0;i<A;i++)
{if(b==a[min]) {printf("您所輸雀蠢入的數為第%d個\n",p[min]); break;}
if(b==a[max]) {printf("您所輸入的數為第%d個\n",p[max]); break;}
if(b==a[mid]) {printf("您所輸入的數為第%d個\n",p[mid]); break;}
if(min>=max) {printf("ERROR 您所輸入的數字%d不在此數組內"); break;}
if(b>a[mid])
{min=mid;<br> mid=(min+max)/2;}
if(b<a[mid])
{ max=mid;
mid=(max+min)/2;}
}
system("pause");
}

❼ c語言折半查找法

折半查找法是演算法一種，可以被任何計算機語言使用。用C語言自然也可以實現。

1、定義：

在計算機科學中，折半搜索（英語：half-interval search），也稱二分搜索（英語：binary search）、對數搜索（英語：logarithmic search），是一種在有序數組中查找某一特定元素的搜索演算法。

搜索過程從數組的中間元素開始，如果中間元素正好是要查找的元素，則搜索過程結束；如果某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。如果在某一步驟數組為空，則代表找不到。這種搜索演算法每一次比較都使搜索范圍縮小一半。

2、查找規則：

折半查找法是效率較高的一種查找方法。假設有已經按照從小到大的順序排列好的五個整數a0~a4，要查找的數是X，其基本思想是： 設查找數據的范圍下限為l=0，上限為h=4，求中點m=（l+h）/2，用X與中點元素am比較，若X等於am，即找到，停止查找；否則，若X大於am，替換下限l=m+1，到下半段繼續查找；若X小於am，換上限h=m-1，到上半段繼續查找；如此重復前面的過程直到找到或者l>h為止。如果l>h，說明沒有此數，列印找不到信息，程序結束。

3、C語言參考代碼：

intbin_search(intA[],intn,intkey){
//在長度為n的數組A中折半查找值為key的元素，並返回下標值。如果不存在則返回-1.
intlow,high,mid;
low=0;
high=n-1;//初始low和high為數組的兩端。
while(low<=high)
{
mid=(low+high)/2;//查找中心點。
if(A[mid]==key)returnmid;//已找到，返回下標值。
if(A[mid]<key){//中點位置比key值小，以mid+1為新的下限值。
low=mid+1;
}
if(A[mid]>key){//中點位置比key值大，以mid-1為新的上限值。
high=mid-1;
}
}
return-1;//未找到，返回-1.
}

❽ A*搜尋演算法的代碼實現(C語言實現)

用C語言實現A*最短路徑搜索演算法，作者 Tittup frog(跳跳蛙)。 #include<stdio.h>#include<math.h>#defineMaxLength100 //用於優先隊列（Open表）的數組#defineHeight15 //地圖高度#defineWidth20 //地圖寬度#defineReachable0 //可以到達的結點#defineBar1 //障礙物#definePass2 //需要走的步數#defineSource3 //起點#defineDestination4 //終點#defineSequential0 //順序遍歷#defineNoSolution2 //無解決方案#defineInfinity0xfffffff#defineEast(1<<0)#defineSouth_East(1<<1)#defineSouth(1<<2)#defineSouth_West(1<<3)#defineWest(1<<4)#defineNorth_West(1<<5)#defineNorth(1<<6)#defineNorth_East(1<<7)typedefstruct{ signedcharx,y;}Point;constPointdir[8]={ {0,1},//East {1,1},//South_East {1,0},//South {1,-1},//South_West {0,-1},//West {-1,-1},//North_West {-1,0},//North {-1,1}//North_East};unsignedcharwithin(intx,inty){ return(x>=0&&y>=0 &&x<Height&&y<Width);}typedefstruct{ intx,y; unsignedcharreachable,sur,value;}MapNode;typedefstructClose{ MapNode*cur; charvis; structClose*from; floatF,G; intH;}Close;typedefstruct//優先隊列（Open表）{ intlength; //當前隊列的長度 Close*Array[MaxLength]; //評價結點的指針}Open;staticMapNodegraph[Height][Width];staticintsrcX,srcY,dstX,dstY; //起始點、終點staticCloseclose[Height][Width];//優先隊列基本操作voidinitOpen(Open*q) //優先隊列初始化{ q->length=0; //隊內元素數初始為0}voidpush(Open*q,Closecls[Height][Width],intx,inty,floatg){ //向優先隊列（Open表）中添加元素 Close*t; inti,mintag; cls[x][y].G=g; //所添加節點的坐標 cls[x][y].F=cls[x][y].G+cls[x][y].H; q->Array[q->length++]=&(cls[x][y]); mintag=q->length-1; for(i=0;i<q->length-1;i++) { if(q->Array[i]->F<q->Array[mintag]->F) { mintag=i; } } t=q->Array[q->length-1]; q->Array[q->length-1]=q->Array[mintag]; q->Array[mintag]=t; //將評價函數值最小節點置於隊頭}Close*shift(Open*q){ returnq->Array[--q->length];}//地圖初始化操作voidinitClose(Closecls[Height][Width],intsx,intsy,intdx,intdy){ //地圖Close表初始化配置 inti,j; for(i=0;i<Height;i++) { for(j=0;j<Width;j++) { cls[i][j].cur=&graph[i][j]; //Close表所指節點 cls[i][j].vis=!graph[i][j].reachable; //是否被訪問 cls[i][j].from=NULL; //所來節點 cls[i][j].G=cls[i][j].F=0; cls[i][j].H=abs(dx-i)+abs(dy-j); //評價函數值 } } cls[sx][sy].F=cls[sx][sy].H; //起始點評價初始值 // cls[sy][sy].G=0; //移步花費代價值 cls[dx][dy].G=Infinity;}voidinitGraph(constintmap[Height][Width],intsx,intsy,intdx,intdy){ //地圖發生變化時重新構造地 inti,j; srcX=sx; //起點X坐標 srcY=sy; //起點Y坐標 dstX=dx; //終點X坐標 dstY=dy; //終點Y坐標 for(i=0;i<Height;i++) { for(j=0;j<Width;j++) { graph[i][j].x=i;//地圖坐標X graph[i][j].y=j;//地圖坐標Y graph[i][j].value=map[i][j]; graph[i][j].reachable=(graph[i][j].value==Reachable); //節點可到達性 graph[i][j].sur=0;//鄰接節點個數 if(!graph[i][j].reachable) { continue; } if(j>0) { if(graph[i][j-1].reachable) //left節點可以到達 { graph[i][j].sur|=West; graph[i][j-1].sur|=East; } if(i>0) { if(graph[i-1][j-1].reachable &&graph[i-1][j].reachable &&graph[i][j-1].reachable) //up-left節點可以到達 { graph[i][j].sur|=North_West; graph[i-1][j-1].sur|=South_East; } } } if(i>0) { if(graph[i-1][j].reachable) //up節點可以到達 { graph[i][j].sur|=North; graph[i-1][j].sur|=South; } if(j<Width-1) { if(graph[i-1][j+1].reachable &&graph[i-1][j].reachable &&map[i][j+1]==Reachable)//up-right節點可以到達 { graph[i][j].sur|=North_East; graph[i-1][j+1].sur|=South_West; } } } } }}intbfs(){ inttimes=0; inti,curX,curY,surX,surY; unsignedcharf=0,r=1; Close*p; Close*q[MaxLength]={&close[srcX][srcY]}; initClose(close,srcX,srcY,dstX,dstY); close[srcX][srcY].vis=1; while(r!=f) { p=q[f]; f=(f+1)%MaxLength; curX=p->cur->x; curY=p->cur->y; for(i=0;i<8;i++) { if(!(p->cur->sur&(1<<i))) { continue; } surX=curX+dir[i].x; surY=curY+dir[i].y; if(!close[surX][surY].vis) { close[surX][surY].from=p; close[surX][surY].vis=1; close[surX][surY].G=p->G+1; q[r]=&close[surX][surY]; r=(r+1)%MaxLength; } } times++; } returntimes;}intastar(){ //A*演算法遍歷 //inttimes=0; inti,curX,curY,surX,surY; floatsurG; Openq;//Open表 Close*p; initOpen(&q); initClose(close,srcX,srcY,dstX,dstY); close[srcX][srcY].vis=1; push(&q,close,srcX,srcY,0); while(q.length) { //times++; p=shift(&q); curX=p->cur->x; curY=p->cur->y; if(!p->H) { returnSequential; } for(i=0;i<8;i++) { if(!(p->cur->sur&(1<<i))) { continue; } surX=curX+dir[i].x; surY=curY+dir[i].y; if(!close[surX][surY].vis) { close[surX][surY].vis=1; close[surX][surY].from=p; surG=p->G+sqrt((curX-surX)*(curX-surX)+(curY-surY)*(curY-surY)); push(&q,close,surX,surY,surG); } } } //printf("times:%d ",times); returnNoSolution;//無結果}constintmap[Height][Width]={ {0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1}, {0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1}, {0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,1}, {0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1}, {0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0}, {0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0}, {0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0}, {0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,1}, {0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0}};constcharSymbol[5][3]={"□","▓","▽","☆","◎"};voidprintMap(){ inti,j; for(i=0;i<Height;i++) { for(j=0;j<Width;j++) { printf("%s",Symbol[graph[i][j].value]); } puts(""); } puts("");}Close*getShortest(){ //獲取最短路徑 intresult=astar(); Close*p,*t,*q=NULL; switch(result) { caseSequential: //順序最近 p=&(close[dstX][dstY]); while(p) //轉置路徑 { t=p->from; p->from=q; q=p; p=t; } close[srcX][srcY].from=q->from; return&(close[srcX][srcY]); caseNoSolution: returnNULL; } returnNULL;}staticClose*start;staticintshortestep;intprintShortest(){ Close*p; intstep=0; p=getShortest(); start=p; if(!p) { return0; } else { while(p->from) { graph[p->cur->x][p->cur->y].value=Pass; printf("（%d，%d）→ ",p->cur->x,p->cur->y); p=p->from; step++; } printf("（%d，%d） ",p->cur->x,p->cur->y); graph[srcX][srcY].value=Source; graph[dstX][dstY].value=Destination; returnstep; }}voidclearMap(){ //ClearMapMarksofSteps Close*p=start; while(p) { graph[p->cur->x][p->cur->y].value=Reachable; p=p->from; } graph[srcX][srcY].value=map[srcX][srcY]; graph[dstX][dstY].value=map[dstX][dstY];}voidprintDepth(){ inti,j; for(i=0;i<Height;i++) { for(j=0;j<Width;j++) { if(map[i][j]) { printf("%s",Symbol[graph[i][j].value]); } else { printf("%2.0lf",close[i][j].G); } } puts(""); } puts("");}voidprintSur(){ inti,j; for(i=0;i<Height;i++) { for(j=0;j<Width;j++) { printf("%02x",graph[i][j].sur); } puts(""); } puts("");}voidprintH(){ inti,j; for(i=0;i<Height;i++) { for(j=0;j<Width;j++) { printf("%02d",close[i][j].H); } puts(""); } puts("");}intmain(intargc,constchar**argv){ initGraph(map,0,0,0,0); printMap(); while(scanf("%d%d%d%d",&srcX,&srcY,&dstX,&dstY)!=EOF) { if(within(srcX,srcY)&&within(dstX,dstY)) { if(shortestep=printShortest()) { printf("從（%d，%d）到（%d，%d）的最短步數是:%d ", srcX,srcY,dstX,dstY,shortestep); printMap(); clearMap(); bfs(); //printDepth(); puts((shortestep==close[dstX][dstY].G)?"正確":"錯誤"); clearMap(); } else { printf("從（%d，%d）不可到達（%d，%d） ", srcX,srcY,dstX,dstY); } } else { puts("輸入錯誤！"); } } return(0);}

❾ HashSet的查找演算法是什麼效率如何

HashSet的contain方法代碼：

map = new HashMap<>(initialCapacity);

public boolean contains(Object o) {
return map.containsKey(o);
}

用的是HashMap的方法，源代碼：

public boolean contains(Object o) {
return containsKey(o);
}

public boolean containsKey(Object key) {
return getEntry(key) != null;
}<span></span> final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key.hashCode());
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}

行了唯衡找到最後發現，就是個遍歷，時間復雜度O(n),好了，二缺山橘分伏團查找完勝。

❿ 二分查找的代碼怎麼寫（其中2種）

二分查找是一種在有序數組中查找指定元素的演算法，它的基本枯氏侍思想是：每次將查找區間縮小一半，直到找到目標元素或者確定目標元素不存在為止。

下面是兩種寫法：

• 遞歸版本

def binary_search(array, target, low, high):

if low > high:

return -1

mid = (low + high) // 2

if array[mid] == target:

return mid

elif array[mid] > target:

return binary_search(array, target, low, mid-1)

else:

return binary_search(array, target, mid+1, high)

# 調用方法

index = binary_search(array, target, 0, len(array)-1)

• 循環版本

def binary_search(array, target):

low, high = 0, len(array) - 1

while low <= high:

mid = (low + high) // 2

if array[mid] == target:

return mid

elif array[mid] > target:

high = mid - 1

else:

low = mid + 1

return -1

# 調用方法

index = binary_search(array, target)

在這里，array 是待查找的有序數組，target 是要查找的元素，low 和 high 分別表示查找區間的左右端點。如果找到了目標元素沒吵，函數會返回其在數組中的下標；如果沒有找到，函數會返核跡回 -1。