查找演算法的實現

Ⅰ 二叉樹查找樹演算法實現

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)<(b))
typedef int ElemType;
typedef int Status;
typedef struct TElemType{
int key;
int num;
}TElemType;
typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

Status SearchBST(BiTree T,int key,BiTree f,BiTree &p){
if(!T) { p=f; return ERROR;}
else if(EQ(T->data.key,key)) { p=T; return OK; }
else if(LT(key,T->data.key))
return SearchBST(T->lchild,key,T,p);
else return SearchBST(T->rchild,key,T,p);
}
Status SearchBST1(BiTree T,int key,BiTree f,BiTree &p){
if(!T) { p=f; return ERROR;}
else if(EQ(T->data.key,key)) {
printf("%d %d",p->data.key,p->data.num);
p=T; return OK; }
else if(LT(key,T->data.key))
return SearchBST(T->lchild,key,T,p);
else return SearchBST(T->rchild,key,T,p);
}
Status InsertBST(BiTree &T,TElemType e){
BiTree s,p;
if(!SearchBST(T,e.key,NULL,p)){
s=(BiTree)malloc(sizeof(BiTNode));
s->data=e;
s->lchild=s->rchild=NULL;
if(!p) T=s;
else if(LT(e.key,p->data.key)) p->lchild=s;
else p->rchild=s;
return OK;
}
}
Status Output(TElemType e){
printf("%d ",e.key);
printf("%d\n",e.num);
}
Status PreOrderTraver( BiTree T){//二叉樹先序遍歷
if(T==NULL) return ERROR;
else{
Output(T->data);
PreOrderTraver(T->lchild);
PreOrderTraver(T->rchild);}
return OK;
}
int main()
{
BiTree T,f=NULL,q;
TElemType a;
int i,n,b;
printf("請輸入你要創建的二叉排序樹的結點個數:\n");
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d",a.key);
scanf("%d",a.num);
InsertBST(T,a);
}
printf("請輸入你要查找的關鍵字: ");{
scanf("%d",b);
if(SearchBST1(T,b,f,q)) printf("查找成功！\n");
else printf("查找失敗！\n");}
printf("二叉樹的先序遍歷:\n");
PreOrderTraver(T);
system("pause");
return 0;
}
這個就是！希望可以幫助你！

Ⅱ php如何實現折半查找演算法

定義：折半查找技術，也就是二分查找。它的前提是線性表中的記錄必須是關鍵碼有序（通常從大到小有序），線性表必須採用順序存儲。

折半查找的基本思想：取中間記錄作為比較對象，若給定值與中間記錄的關鍵字，則在中間記錄的關鍵字相等，則查找成功；若給定值小於中間記錄的作伴去繼續查找；若給定值大於中間記錄的關鍵字，則在中間記錄的右半區繼續查找。不斷重復上述過程，直到查找成功，或所有查找區域無記錄，查找失敗為止。

實現代碼：
<?php //遞歸方式 function bin_recur_search($arr,$val){ global $time; if(count($arr) >= 1){ $mid = intval(count($arr) / 2); $time++; if($arr[$mid] == $val){ return '值為:'.$arr[$mid].'<br>查找次數：'.$time.'<br>'; }elseif($arr[$mid] > $val){ $arr = array_splice($arr,0,$mid); return bin_recur_search($arr, $val); }else{ $arr = array_slice($arr,$mid + 1); return bin_recur_search($arr, $val); } } return '未找到'.$val; } //非遞歸方式 function bin_search($arr,$val){ if(count($arr) >= 1){ $low = 0; $high = count($arr); $time = 0; while($low <= $high){ $time++; $mid = intval(($low + $high)/2); if($val == $arr[$mid]){ return '索引：'.$mid.'<br>值為：'.$arr[$mid].'<br>查找次數：'.$time; }elseif($val > $arr[$mid]){ $low = $mid + 1; }else{ $high = $mid - 1; } } } return '未找到'.$val; } $arr = array(1,3,5,7,7,9,25,68,98,145,673,8542); echo bin_recur_search($arr, 673); echo bin_search($arr, 673); ?>
運行結果：
值為:673 查找次數：4 索引：10 值為：673 查找次數：4
更多關於PHP相關內容感興趣的讀者可查看本站專題：《PHP數據結構與演算法教程》、《php程序設計演算法總結》、《php字元串(string)用法總結》、《PHP數組(Array)操作技巧大全》、《PHP常用遍歷演算法與技巧總結》及《PHP數學運算技巧總結》

Ⅲ java中的查找演算法如何實現... 高手幫幫忙

這個。。。我隨便亂說幾句啊，說的不對別見笑。

有一個數組 當中存有一些字元串
另外有一個字典文件 我也將它導入一個數組 有50000多個單詞
然後要找出字元串中包含的單詞

由你給的條件可知：
1。數組 應該是從前到後依次順序掃描字元串。
2。50000多個單詞的字典文件一定優化。具體優化要看具體內容吧。
比如你可以按單詞的首字母排序，然後分組。等掃描字元串的時候可以分組比較。但這種方法應該沒省多少時間。
你還可以把50000多個單詞的字典文件按單詞的長度進行分組。比如1個字母的分成一組，二個字母的分成一組。。。。N個字母的分成一組，這樣就分成了N組。然後掃描字元串的時候你可以按後續匹配（好象叫這個演算法吧，名字記不清了）演算法，這樣就可以省很多時間了。
你還可以這樣做，因為你要查的是單詞，單詞一定有意義。那你可以直接把你的字元串數組先進行語法、語義分析並分割，然後再去匹配你的字典。這樣應該是最快的。但這要用到自然語言處理。。。

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

Ⅳ java二分法查找的遞歸演算法怎麼實現

publicclass二分法遞歸查找{
	publicstaticvoidmain(String[]args){

		//定義數組,注意,二分查找數組必須是有序的數組!
		int[]arr={1,3,5,7,9,11,13,15,17};
		
		//接受查找後的返回值:索引值,如果沒有則是-1;
		//測試查找元素:9
		inta=binary(arr,9,0,arr.length-1);
		System.out.println("被查找數字索引位置在:"+a);
	}
	//參數列表依次為:被查找的數組,查找的數字,頭索引,尾索引!
	publicstaticintbinary(int[]arr,intkey,intstar,intend)//遞歸
	{
		//每次進來創建,中間索引值!
		intmid=(star+end)/2;
		//如果被查找數小於頭,或者尾,或者頭索引大於尾索引,則說明無該數,返回-1;
		if(key<arr[star]||key>arr[end]||star>end){
			return-1;
		}
		//如果中間值小於被查找數,則重新定義頭索引移至中間+1位置,篩選掉一半數字!
		if(arr[mid]<key){
			//開始遞歸!
			returnbinary(arr,key,mid+1,end);
			//否則如果中間值大於被查找數,則重新尾索引移至中間-1位置,篩選掉一半數字!
		}elseif(arr[mid]>key){
			//開始遞歸!
			returnbinary(arr,key,star,mid-1);
		}else{
			//否者就是找到了,返回該索引!
			returnmid;
		}
	}
}

Ⅵ PHP二分查找演算法的實現方法示例

本文實例講述了PHP二分查找演算法的實現方法。分享給大家供大家參考，具體如下：
二分查找法需要數組是一個有序的數組
假設我們的數組是一個遞增的數組，首先我們需要找到數組的中間位置.
1.
要知道中間位置就需要知道起始位置和結束位置，然後取出中間位置的值來和我們的值做對比。
2.
如果中間值大於我們的給定值，說明我們的值在中間位置之前，此時需要再次二分，因為在中間之前，所以我們需要變的值是結束位置的值，此時結束位置的值應該是我們此時的中間位置。
3.
反之，如果中間值小於我們給定的值，那麼說明給定值在中間位置之後，此時需要再次將後一部分的值進行二分，因為在中間值之後，所以我們需要改變的值是開始位置的值，此時開始位置的值應該是我們此時的中間位置，直到我們找到指定值。
4.
或者中間值等於最初的起始位置，或結束位置（此時說明給定值未找到），下面我們來用代碼實現~
//循環實現
function
getValue($num,$arr)
{
//查找數組的中間位置
$length=count($arr);
$start=0;
$end=$length;
$middle=floor(($start+$end)/2);
//循環判斷
while($start>$end-1)
{
if($arr[middle]==$num)
{
return
middle+1;
}
elseif($arr[middle]<$num)
{
//如果當前要查找的值比當前數組的中間值還要打，那麼意味著該值在數組的後半段
//所以起始位置變成當前的middle的值，end位置不變。
$start=$middle;
$middle=floor(($start+$end)/2);
}
else{
//反之
$end=$middle;
$middle=floor(($start+$end)/2);
}
}
return
false;
}
//遞歸實現
/*
*
從數組中獲取元素值
*
@param1
int
$num，要查找的目標值
*
@param2
array
$arr，要查找的數組
*
@param3
int
$start，查找的起始位置
*
@param4
int
$end，查找的結束位置
*
@return
mixed，找到了返回位置，沒找到返回false
*/
function
getValue4($num,$arr,$start
=
0,$end
=
100){
//採用二分法查找
$middle
=
floor(($end
+
$start)
/
2);
//判斷
if($arr[$middle]
==
$num){
//已經找到了，遞歸的出口
return
$middle
+
1;
}elseif($arr[$middle]
<
$num){
//要查找的元素在數組的後半段
$start
=
$middle
+
1;
//邊界值
if($start
>=
$end){
//沒有找到，但是已經超出邊界值，遞歸出口
return
false;
}
//調用自己去查找：遞歸點
return
getValue4($num,$arr,$start,$end);
//getValue4($num,$arr,51,100)
}else{
//要查找的元素在數組的前半段
$end
=
$middle
-
1;
//判斷邊界值
if($end
<
0)return
false;
//調用自己：遞歸點
return
getValue4($num,$arr,$start,$end);
//getValue4($num,$arr,0,49)
}
//都沒有找到
return
false;
}
更多關於PHP相關內容感興趣的讀者可查看本站專題：《PHP數據結構與演算法教程》、《PHP基本語法入門教程》、《php面向對象程序設計入門教程》、《php字元串(string)用法總結》及《php查找技巧與方法總結》
希望本文所述對大家PHP程序設計有所幫助。

Ⅶ 查找的計算機演算法

⒈順序查找的思想是：
將查找值順序逐個與結點值進行比較，相等即為查找成功，否則查找失敗.
程序如下：
program sxcz;
const n=7;
type
arr=array[1..n] of integer;
var x1,i:integer;
a:arr;
b:boolean;
place:integer;
procere search(r:arr;m,x:integer; var found:boolean;var p:integer);
begin
p:=1;found:=false;
while(p<=m) and not found do
if r[p]=x then found:=true else p:=p+1;
end;
begin
write('Enter array:');
for i:=1 to n do read(a[i]);
writeln;
write('Enter search data:');
read(x1）；
search(a,n,x1,b,place);
if b then begin writeln('yes');writeln('Place of',x1:5,'is:',place); end
else writeln('no');
end. ⒈二分查找的基本思想：首先將結點按關鍵字排序，其次將查找值與中間位置的值比較，相等，查找成功；不等，則中間數據大於或小於查找值，無論怎樣查找將在一半的數據中查找。
⒉例：輸入序列數據查找指定值.
程序：
program sxcz;
const n=7;
type
arr=array[1..n] of integer;
var x1,i:integer;
a:arr;
place:integer;
procere paixv(var r:arr;m:integer);
var k,j,i,t:integer;
begin
k:=m;
while k>0 do
begin
j:=k-1;k:=0;
for i:=1 to j do
if r[i]>r[i+1] then
begin t:=r[i];a[i]:=r[i+1];r[i+1]:=t;k:=i;end;
end;
end;
procere search(r:arr;m,x:integer; var p:integer);
var low,high,mid:integer;
begin
p:=0;low:=1;high:=m;
while low<=high do
begin
mid:=(low+high) div 2;
if x>r[mid] then low:=mid+1 else
if x<r[mid] then high:=mid-1 else
begin p:=mid;exit;end;
end;
end;
begin
write('Enter array:');
for i:=1 to n do read(a[i]);
writeln;
write('Enter search data:');
read(x1）；
paixv(a,n);
search(a,n,x1,place);
if place<>0 then writeln('yes') else writeln('no');
end. 因為二叉排序樹的左子樹若不為空則左子樹的所有結點的值均小於它的根結點的值，而右子樹若不為空，則右子樹的所有結點的值均不小大於它的根結點的值，根據這個性質查找演算法如下：
program pxtree;
const
a:array[1..8] of integer=（10,18,3,8,12,2,7,3）；
type point=^nod;
nod=record
w:integer;
right,left:point ;
end;
var root,first:point;k:boolean;i,x:integer;
procere maketr(d:integer;var p:point);
begin
if p=nil then
begin
new(p);
with p^ do begin w:=d;right:=nil;left:=nil end;
if k then begin root:=p; k:=false end;
end
else with p^ do if d>=w then maketr(d,right) else maketr(d,left);
end;
function searchtr(x:integer;p:point):boolean;
begin
if p=nil then searchtr:=false
else if x=p^.w then searchtr:=true
else if x<p^.w then searchtr:=searchtr(x,p^.left)
else searchtr:=searchtr(x,p^.right);
end;
begin
first:=nil;k:=true;
for i:=1 to 8 do maketr(a[i],first);
write('want find data x:');read(x);
if searchtr(x,first) then writeln('yes') else writeln('No');
end. 以上講的查找方法基於比較的，查找效率依賴比較次數，其實理想的查找希望不經比較，一次存取便能得到所查記錄，那就必須在記錄的存儲位置和它的關鍵字之間建立一個確定的對應關系f，這樣查找k時，只要根據這個對應關系f找到給定值k的像f(k）。這種對應關系f叫哈希（hash）函數。按這種思想建立的表叫哈希表（也叫散列表）。哈希表存取方便但存儲時容易沖突（collision）：即不同的關鍵字可以對應同一哈希地址。如何確定哈希函數和解決沖突是關鍵。
⒈哈希函數的構造方法
直接定址法：H(k)=k 或H(k)=a*k+b（線形函數）
如：人口數字統計表 地址 1 2 3 ... 100 年齡 1 2 3 ... 100 人數 67 3533 244 ... 4 數字分析法：取關鍵字的若干數位組成哈希地址
如：關鍵字如下：若哈希表長為100則可取中間兩位10進制數作為哈希地址。 81346532 81372242 81387422 81301367 81322817 81338967 81354157 81368537 平方取中法：關鍵字平方後取中間幾位數組成哈希地址
折疊法：將關鍵數字分割成位數相同的幾部分（最後一部分的位數可以不同）然後取幾部分的疊加和（捨去進位）作為哈希地址。
除留余數法：取關鍵字被某個不大於表長m的數p除後所得的余數為哈希地址。
H(k)=k mod p p<=m
隨機數法：H(k)=rondom(k）。
⒉處理沖突的方法
假設地址集為0..n-1，由關鍵字得到的哈希地址為j(0<=j<=n-1）的位置已存有記錄，處理沖突就是為該關鍵字的記錄找到另一個空的哈希地址。在處理中可能得到一個地址序列Hi i=1，2，...k
0<=Hi<=n-1），即在處理沖突時若得到的另一個哈希地址H1仍發生沖突，再求下一地址H2，若仍沖突，再求H3...。怎樣得到Hi呢？
開放定址法：Hi=(H(k)+di) mod m （H(k）為哈希函數；m為哈希表長；di為增量序列）
當di=1，2，3，... m-1 時叫線性探測再散列。
當di=1，-1，2，-2，3，-3，...,k,-k時叫二次探測再散列。
當di=random（m）時叫偽隨機探測序列。
例：長度為11的哈希表關鍵字分別為17，60，29，哈希函數為H(k)=k mod 11，第四個記錄的關鍵字為38，分別按上述方法添入哈希表的地址為8，4，3（隨機數=9）。
再哈希法：Hi=RHi(key) i=1,2,...,k，其中RHi均為不同的哈希函數。
鏈地址法：這種方法很象基數排序，相同的地址的關鍵字值均鏈入對應的鏈表中。
建立公益區法：另設一個溢出表，不管得到的哈希地址如何，一旦發生沖突，都填入溢出表。
⒊哈希表的查找
例：如下一組關鍵字按哈希函數H(k)=k mod 13和線性探測處理沖突所得的哈希表a[0..15]: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 14 01 68 27 55 19 20 84 79 23 11 10 當給定值k=84，則首先和a[6]比在依次和a[7],a[8]比結果a[8]=84查找成功。
當給定值k=38，則首先和a[12]比，再和a[13]比，由於a[13]沒有，查找不成功，表中不存在關鍵字等於38的記錄。 查找第k小元素即在n個元素中（未排序）找到第k小的元素。方法同快速排序，採用遞歸方式。
程序如下：
program kspv;
const n=7;
type
arr=array[1..n] of integer;
var
b:arr;
i,k:integer;
function p(s,t:integer):integer;
var i,j,t1,x:integer;
begin
i:=s;j:=t;x:=b[i];
repeat
while (b[j]>=x) and (j>i) do j:=j-1;
if j>i then begin t1:=b[i]; b[i]:=b[j];b[j]:=t1;end;
while (b[i]<=x) and (i<j) do i:=i+1;
if i<j then begin t1:=b[j];b[j]:=b[i];b[i]:=t1; end
until i=j;
b[i]:=x;
p:=i;
end;
function find(s,t,k:integer):integer;
var p1,q:integer;
begin
if s=t then find:=b[s] else
begin
p1:=p(s,t);
q:=p1-s+1;
if k<=q then find:=find(s,p1,k) else find:=find(p1+1,t,k-q);
end;
end;
begin
write('input data:');
for i:=1 to n do read(b[i]);readln;
write('input k:');read(k);
write('output data:');
writeln('kthsmall:=',find（1,n,k));
end.

Ⅷ 資料庫得查詢功能是怎麼實現的

資料庫的查詢功能實現原理：

資料庫查詢是資料庫的最主要功能之一。我們都希望查詢數據的速度能盡可能的快，因此資料庫系統的設計者會從查詢演算法的角度進行優化。最基本的查詢演算法當然是順序查找（linear search），這種復雜度為O(n)的演算法在數據量很大時顯然是糟糕的，好在計算機科學的發展提供了很多更優秀的查找演算法，例如二分查找（binary search）、二叉樹查找（binary tree search）等。如果稍微分析一下會發現，每種查找演算法都只能應用於特定的數據結構之上，例如二分查找要求被檢索數據有序，而二叉樹查找只能應用於二叉查找樹上，但是數據本身的組織結構不可能完全滿足各種數據結構（例如，理論上不可能同時將兩列都按順序進行組織），所以，在數據之外，資料庫系統還維護著滿足特定查找演算法的數據結構，這些數據結構以某種方式引用（指向）數據，這樣就可以在這些數據結構上實現高級查找演算法。這種數據結構，就是索引。

圖1展示了一種可能的索引方式。左邊是數據表，一共有兩列七條記錄，最左邊的是數據記錄的物理地址（注意邏輯上相鄰的記錄在磁碟上也並不是一定物理相鄰的）。為了加快Col2的查找，可以維護一個右邊所示的二叉查找樹，每個節點分別包含索引鍵值和一個指向對應數據記錄物理地址的指針，這樣就可以運用二叉查找在O(log2n)O(log2n)的復雜度內獲取到相應數據。

Ⅸ 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;
}
折半查找運行結果：
三、實驗總結：
該實驗使用了兩種查找數據的方法（順序查找和折半查找），這兩種方法的不同之處在於查找方式和過程不同，線性表的創建完全相同，程序較短，結果也一目瞭然。

Ⅹ 二分搜索演算法是利用什麼實現的演算法

二分搜索演算法是利用排除剩餘元素中一半的元素實現的演算法。

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

二分搜索演算法原理：

1、如果待查序列為空，那麼就返回－1，並退出演算法；這表示查找不到目標元素。如果待查序列不為空，則將它的中間元素與要查找的目標元素進行匹配，看它們是否相等。如果相等，則返回該中間元素的索引，並退出演算法；此時就查找成功了。如果不相等，就再比較這兩個元素的大小。

2、如果該中間元素大於目標元素，那麼就將當前序列的前半部分作為新的待查序列；這是因為後半部分的所有元素都大於目標元素，它們全都被排除了。

3、如果該中間元素小於目標元素，那麼就將當前序列的後半部分作為新的待查序列；這是因為前半部分的所有元素都小於目標元素，它們全都被排除了。