曦~妍  
查询资料：二分查找法

二分查找

 编辑

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

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
中文名
二分查找
外文名
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);
}
}
}
posted on 2016-05-10 21:38  曦~妍  阅读(244)  评论(0)    收藏  举报
 
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3