查询资料：二分查找法

二分查找

 编辑

同义词 二分查找法一般指二分查找

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

中文名

二分查找

外文名

Binary-Search

别    称

折半查找

应用学科

计算机

优    点

查找速度快

缺    点

待查表为有序表

目录

1. 1 算法要求
2. 2 算法复杂度
3. 3 代码示例
4. ▪ Python源代码

1. ▪ pascal源代码
2. ▪ C语言代码
3. ▪ Java代码
4. ▪ AAuto代码
5. ▪ PHP代码

1. ▪ C++代码
2. ▪ AS3代码
3. ▪ JavaScript代码
4. ▪ PHP代码

算法要求

编辑

1. 必须采用顺序存储结构

2.必须按关键字大小有序排列。

算法复杂度

编辑

二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x.

时间复杂度无非就是while循环的次数！

总共有n个元素，

渐渐跟下去就是n,n/2,n/4,....n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数

由于你n/2^k取整后>=1

即令n/2^k=1

可得k=log2n,（是以2为底，n的对数）

所以时间复杂度可以表示O()=O(logn)

下面提供一段二分查找实现的伪代码:

BinarySearch(max,min,des)

mid-<(max+min)/2

while(min<=max)

mid=(min+max)/2

if mid=des then

return mid

elseif mid >des then

max=mid-1

else

min=mid+1

return max

折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。如 果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。如果x>a[n/2]，则我们只要在数组a的右 半部继续搜索x。

代码示例

编辑

Python源代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

def binarySearch(lists,select):     is_none=False     iflists!=[]:     cen_num=len(lists)/2     tlag=lists[cen_num]     gt_list=lists[0:cen_num]     lt_list=lists[cen_num+1:]   if tlag==select:     is_none=True     return is_none elif tlag>select:     is_se=binarySearch(gt_list,select)     if notis_se:         return binarySearch(lt_list,select)     return is_none     elif tlag<select:         is_se=binarySearch(lt_list,select) if notis_se:     return binarySearch(gt_list,select) return is_none

pascal源代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

programjjzx(input,output); var a:array[1..10]ofinteger; i,j,n,x:integer; begin ['输入10个从小到大的数：'] for i:=1 to 10 do read(a[i]); ['输入要查找的数：'] readln(x); i:=1;n:=10;j:=trunc((i+n)/2); repeat if a[j]>x then begin n:=j-1;j:=trunc((i+n)/2) end else if a[j]<x then begin i:=j+1;j:=trunc((i+n)/2) end; until(a[j]=x)or(i>=n);{为什么是这个结束循环条件——i>n表示所查找的范围已经空了（就是没找到）} if a[j]=x then writeln('查找成功！位置是：',j:3) else writeln('查找失败，数组中无此元素！') end.

C语言代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

int BinSearch(SeqList *R，int n,KeyType K) { //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1 int low=0，high=n-1，mid；//置当前查找区间上、下界的初值 while(low<=high) { if(R[low].key==K) return low; if(R[high].key==k) return high; //当前查找区间R[low..high]非空 mid=low+((high-low)/2)； //使用(low+high)/2会有整数溢出的问题 //（问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时， //这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题 if(R[mid].key==K) return mid；//查找成功返回 if(R[mid].key<K) low=mid+1；//继续在R[mid+1..high]中查找     else high=mid-1;//继续在R[low..mid-1]中查找   } if(low>high) return -1；//当low>high时表示所查找区间内没有结果，查找失败 }//BinSeareh   ------------上面代码复杂难懂----------------- int bsearchWithoutRecursion(intarray[],int low,int high,int target) { while(low<=high) { int mid=(low+high)/2; if(array[mid]>target) high=mid-1; elseif(array[mid]<target) low=mid+1; else//findthetarget return mid; } //the array does not contain the target return-1; } ----------------------------------------

递归实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14

intbinary_search(constintarr[],intlow,inthigh,intkey) { int mid=low+(high-low)/2; if(low>high) return -1; else{ if(arr[mid]==key) return mid; else if(arr[mid]>key) return binary_search(arr,low,mid-1,key); else return binary_search(arr,mid+1,high,key); } }

Java代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public static int binarySearch(Integer[] srcArray, int des) {     int low = 0;     int high = srcArray.length - 1;       while ((low <= high) && (low <= srcArray.length - 1)             && (high <= srcArray.length - 1)) {         int middle = (high + low) >> 1;         if (des == srcArray[middle]) {             return middle;         } else if (des < srcArray[middle]) {             high = middle - 1;         } else {             low = middle + 1;         }     }     return -1; }

AAuto代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

//二分查找 functionbinSearch(t,v){ varp=#t; varp2; varb=0; do{ p2=p; p=b+math.floor((p-b)/2)//二分折半运算 if(p==b)return; if(t[p]<v){//判断下限 b=p; p=p2; } }while(t[p]>v)//判断上限 returnt[p]==v&&p; } //测试 tab={} //创建数组，每个元素都是随机数 for(i=1;10;1){ tab[i]=math.random(1,10000) } //插入一个已知数 table.push(tab,5632) //排序 table.sort(tab) io.open() io.print("数组",table.tostring(tab)) io.print("使用二分查找，找到5632在位置：",binSearch(tab,5632)) }

PHP代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

function binsearch($x,$a){ $c=count($a); $lower=0; $high=$c-1; while($lower<=$high){ $middle=intval(($lower+$high)/2); if($a[$middle]>$x) $high=$middle-1; elseif($a[$middle]<$x) $lower=$middle+1; else return $middle; } return -1; }

C++代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

int binSearch(const int *Array,int start,int end,int key) {     int left,right;     int mid;     left=start;     right=end;     //注释中为递归算法，执行效率低，不推荐     /*     if(key<Array[mid])     {         return(binSearch(Array,left,mid,key));     }     else if(key>Array[mid])     {         return(binSearch(Array,mid+1,right,key));     }     else     return mid;     */       while(left<=right)     {         mid=(left+right)/2;         if(key==Array[mid])  return mid;         else if(key<Array[mid]) right=mid-1;         else if(key>Array[mid]) left=mid+1;     }     return -1;     //找不到就返回-1 }

AS3代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

publicstaticfunctionbinSearch(list:Array,low:int,high:int,key:int):int{ if(low>high) return-1; varmid:int=low+int((high-low)/2); varindex:int=-1 if(list[mid]==key){ index=mid; }elseif(list[mid]<key){ low=mid+1; index=binSearch(list,low,high,key); }else{ high=mid-1; index=binSearch(list,low,high,key); }returnindex; }

JavaScript代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

varArr=[3,5,6,7,9,12,15]; functionbinary(find,arr,low,high){ if(low<=high){ if(arr[low]==find) returnlow; if(arr[high]==find) returnhigh; varmid=Math.ceil((high+low)/2); if(arr[mid]==find){ returnmid; }elseif(arr[mid]>find){ returnbinary(find,arr,low,mid-1); }else{ returnbinary(find,arr,mid+1,high); } } return-1; } binary(15,Arr,0,Arr.length-1);

PHP代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/*二分查找：前提，该数组已经是一个有序数组，必须先排序，再查找。*/ functionbinarySearch(&$array,$findVal,$leftIndex,$rightIndex){ $middleIndex=round(($rightIndex+$leftIndex)/2); if($leftIndex>$rightIndex){ echo'查无此数<br/>'; return; } if($findVal>$array[$middleIndex]){ binarySearch($array,$findVal,$middleIndex+1,$rightIndex); }elseif($findVal<$array[$middleIndex]){ binarySearch($array,$findVal,$leftIndex,$middleIndex-1); }else{ echo"找到数据:index=$middleIndex;value=$array[$middleIndex]<br/>"; if($array[$middleIndex+1]==$array[$middleIndex]&&$leftIndex<$rightIndex){ binarySearch($array,$findVal,$middleIndex+1,$rightIndex); } if($array[$middleIndex-1]==$array[$middleIndex]&&$leftIndex<$rightIndex){ binarySearch($array,$findVal,$leftIndex,$middleIndex-1); } } }