二分查找（Binary Search）常见问题解决方法总结

缘由

今天浏览 何登成的技术博客  无意中发现了写的blog，二分查找(Binary Search)需要注意的问题，以及在数据库内核中的实现。

随想总结下二分查找的常见问题。

问题背景

今年的实习生招聘考试，我出了一道二分查找(Binary Search)的题目。题目大意如下：

给定一个升序排列的自然数数组，数组中包含重复数字，例如：[1,2,2,3,4,4,4,5,6,7,7]。

问题：给定任意自然数，对数组进行二分查找，返回数组正确的位置，给出函数实现。

注：连续相同的数字，返回第一个匹配位置还是最后一个匹配位置，由函数传入参数决定。

 在这片博客中作者也详细说明了，二分查找的重要性，比如在数据库的内核实现中，二分查找是一个非常重要的逻辑，几乎99%以上的

SQL语句(所有索引上的范围扫描/等值查询/Unique查询等)，都会使用到二分查找进行数据的定位。 可以看到二分查找在现实的重要性。

二分查找算法的思想

二分查找法主要是解决在“一堆数中找出指定的数”这类问题。

而想要应用二分查找法，这“一堆数”必须有一下特征：

• 存储在数组中
• 有序排列

所以如果是用 链表 存储的，就无法在其上应用 二分查找法 了。

其实二分查找算法的思想很简单，在《编程珠玑》一书中的描述：

 在一个包含x的数组内，二分查找通过对范围的跟综来解决问题。开始时，范围就是整个数组。通过将范围中间的元素

与x比较并丢弃一半范围，范围就被缩小。这个过程一直持续，直到在x被发现，或者那个能够包含t的范围已成为空。

 Donald Knuth在他的《Sorting and Searching》一书中指出，尽管第一个二分查找算法早在1946年就被发表，但第一个

没有bug的二分查找算法却是在12年后才被发表出来。

注意中间值下标的计算，如果写成(low+high)/2，low+high可能会溢出，从而导致数组访问出错。改进的方法是将计算方式

写成如下形式：low+ ( (high-low) >>1)。

常见问题解决

在何登成的技术博客中的问题四 “如何查找第一个/最后一个等值”，这个大牛只是简单的说明了下，并没有详细说明怎么解决

这个问题，下面来探讨 怎么解决 当所给有序重复数组 中查找 某个值出现的 第一个 和最后一个位置。

主要是下面三个问题：

1）二分查找元素x的下标，如无 return  -1

2）二分查找返回x(可能有重复)第一次出现的下标，如无return  -1

3）二分查找返回x(可能有重复)最后一次出现的下标，如无return  -1

对于问题1 我们只需要 利用最原始的的二分查找即可。

代码如下：

[cpp]  view plain  copy

1. /*  
2. bin_search 二分查找元素x的下标，如无 return -1 
3. low,high 分别为待查元素的区间的 上下界(包含边界). 
4. x为待查元素. 
5. 注意 low <= high  
6. */  
7. int bin_search(int *a, int low, int high, int x)  
8. {  
9.     if(NULL == a || low > high)  
10.         return -1;  
11.   
12.     int mid;  
13.     while(low<=high)//注意是<=，若是<会找不到边界值情况  
14.     {  
15.         mid = low + ((high-low)>>1);  
16.         if(x<a[mid])  
17.             high = mid-1;  
18.         else if(x>a[mid])  
19.             low = mid +1;  
20.         else  
21.             return mid;  
22.     }  
23.     return -1;  
24. }  

对于问题2，二分查找返回x(可能有重复 )第一次出现的下标 ，如无return  -1。

我们只需找到x重复出现情况下的第一次出现的下标。则我们只需用a[mid]和元素x进行比较，当a[mid]<x时

此时待查元素肯定在待查区间的右半部分 显然此时 不包括 mid 所以有 low = mid+1, 若a[mid]>=x时, 因为我

们查找的是x第一次出现的位置,我们不关心x最后出现的位置,所以此时high下标为mid,直到 low == high 终止

循环，并且比较a[low]是否为x,若是则 找到。

总的思路是：

把有序序列分成2个序列:[first,mid][mid+1,last) 当 a[mid]<x 时 使用 使用序列[mid + 1,last)

当 a[mid]>=x 时 使用序列[first,mid]。

还是看代码吧。

[cpp]  view plain  copy

1. /*  
2. binS_first二分查找返回x(可能有重复)第一次出现的下标，如无return -1 
3. low,high 分别为待查元素的区间的 上下界(包含边界). 
4. //分成2个序列:[first,mid][mid+1,last) 
5.   x为待查元素.注意 循环结束条件，low == high */  
6. int binS_first(int *a, int low, int high, int x)  
7. {  
8.     if(NULL == a || low > high)return -1;  
9.     int mid;  
10.     while(low<high)  
11.     {  
12.         mid=low+((high-low)>>1);//计算中点  
13.         if(a[mid]<x)// <x ,调整起点或者终点  
14.             low=mid+1;  
15.         else // >=x  
16.             high=mid;  
17.     }  
18.     if(a[low] == x)  
19.         return low;  
20.     return -1;  
21. }  

 

对于问题3，二分查找返回x(可能有重复)最后一次出现的下标，如无return  -1

其实和问题2的思路差不多。

只是在 while中我们假定 low+1 < high,否则在只有两个或者一个元素时 我们只需在while循环之外判断即可。

接下来的while 情况和问题2等价。我们现在关心的是 x(可能有重复)最后一次出现的下标，所以现在我们不关心他

第一次出现下标的位置, 当 a[mid]<=x 时 low = mid, 否则 a[mid] >x 此时 high = mid -1. 代码如下：

[cpp]  view plain  copy

1. /*  
2. binS_last二分查找返回x(可能有重复)最后一次出现的下标,如无return -1 
3. low,high 分别为待查元素的区间的 上下界(包含边界). 
4. x为待查元素. 
5. 注意 循环结束条件，low+1 == high  
6. */  
7. int binS_last(int *a, int low, int high, int x)    
8. {    
9.     if(NULL == a || low > high)  
10.         return -1;  
11.     int mid;      
12.     while(low+1<high)//**     
13.     {    
14.         mid=low+((high-low)>>1);    
15.         if(a[mid]<=x)  // <=x  
16.             low = mid;    
17.         else  // >x  
18.             high=mid-1;    
19.     }    
20.     if(a[high] == x)//先判断high  
21.         return high;  
22.     else if(a[low] == x)  
23.         return low;  
24.     return -1;  
25. }    

查找重复元素出现的第一次 最后一次位置总结如下：

二分查找返回x(可能有重复)第一次(最后一次)出现的下标找最小的等号放>=x位置(high),找最大的等号放<=x的位置(low)。
其中a[mid]在和待查找元素x比较中带 = 的，在对low 或者high赋值时一定为 mid，其它情况(<或>)则为mid+(-)1.

总的测试程序。

[cpp]  view plain  copy

1. #include <stdio.h>  
2. /* 
3. bin_search 二分查找元素x的下标，如无 return -1 
4. low,high 分别为待查元素的区间的 上下界(包含边界). 
5. x为待查元素. 
6. 注意 low <= high 
7. */  
8. int bin_search(int *a, int low, int high, int x)  
9. {  
10.     if(NULL == a || low > high)  
11.         return -1;  
12.   
13.     int mid;  
14.     while(low<=high)//注意是<=，若是<会找不到边界值情况  
15.     {  
16.         mid = low + ((high-low)>>1);  
17.         if(x<a[mid])  
18.             high = mid-1;  
19.         else if(x>a[mid])  
20.             low = mid +1;  
21.         else  
22.             return mid;  
23.     }  
24.     return -1;  
25. }  
26. /* 
27. binS_first二分查找返回x(可能有重复)第一次出现的下标,如无return -1 
28. low,high 分别为待查元素的区间的 上下界(包含边界). 
29. //分成2个序列:[first,mid][mid+1,last) 
30. x为待查元素. 
31. 注意 循环结束条件，low == high */  
32. int binS_first(int *a, int low, int high, int x)  
33. {  
34.     if(NULL == a || low > high)return -1;  
35.     int mid;  
36.     while(low<high)//<  
37.     {  
38.         mid=low+((high-low)>>1);  
39.         if(a[mid]<x)// <x  
40.             low=mid+1;  
41.         else // >=x  
42.             high=mid;  
43.     }  
44.     if(a[low] == x)  
45.         return low;  
46.     return -1;  
47. }  
48. /* 
49. binS_last二分查找返回x(可能有重复)最后一次出现的下标, 
50. 如无return -1 
51. low,high 分别为待查元素的区间的 上下界(包含边界). 
52. x为待查元素.注意 循环结束条件，low+1 == high */  
53. int binS_last(int *a, int low, int high, int x)  
54. {  
55.     if(NULL == a || low > high)  
56.         return -1;  
57.     int mid;  
58.     while(low+1<high)//**  
59.     {  
60.         mid=low+((high-low)>>1);  
61.         if(a[mid]<=x) // <=x  
62.             low = mid;  
63.         else // >x  
64.             high=mid-1;  
65.     }  
66.     if(a[high] == x)//先判断high  
67.         return high;  
68.     else if(a[low] ==x)return low;  
69.     return -1;  
70. }  
71. int main()  
72. {  
73.     int a[]= {-1,1,2,2,2,4,4,4,4,4,4,4}; //0-11  
74.     printf("-1: %d\n", bin_search(a, 0, 11, -1));  
75.     printf(" 4 fisrt: %d\n", binS_first(a, 0, 11, 4));  
76.     printf(" 4 last: %d\n", binS_last(a, 0, 11, 4));  
77.     printf("\n");  
78.     int b[]= {-2,-2,0,5,5,7,7}; //0-6  
79.     printf("-2 fisrt: %d\n", binS_first(b, 0, 6, -2));  
80.     printf("-2 last: %d\n", binS_last(b, 0, 6, -2));  
81.     printf(" 5 fisrt: %d\n", binS_first(b, 0, 6, 5));  
82.     printf(" 5 last: %d\n", binS_last(b, 0, 6, 5));  
83.     return 0;  
84. }  

运行结果截图：

                     

此外对于像，二分查找返回刚好小于x的元素下标，二分查找返回刚好大于x的元素下标， 返回有序数列某一个元素重复出现的次数等问题，可以根据上面

的寻找重复元素出现第一次 最后一次位置的方法 进行 问题求解。对于这类问题也可以参考 STL 中关于 lower_bound与upper_bound的实现。STL算法库

中已经有相关实现。

参考：

http://hedengcheng.com/?p=595

编程珠玑

http://blog.csdn.net/daniel_ustc/article/details/17307937