二分查找的注意事项

最新推荐文章于 2025-04-02 07:51:43 发布

silence401

最新推荐文章于 2025-04-02 07:51:43 发布

阅读量772

点赞数

分类专栏：心得

心得专栏收录该内容

2 篇文章

订阅专栏

二分查找的各种情况实现以及一些注意点

标签：二分查找编程之美面试详细解答算法

2015-04-28 20:38 539人阅读评论(2) 收藏举报

分类：

数据结构及算法（14）

转载请注明出处，谢谢：

http://blog.csdn.NET/u014285517/article/details/45341741

说真的自己开始也认为二分查找实在太简单了，不屑一顾，可是上礼拜阿里实习面试真是教会我做人要踏实啊！上礼拜面试的事等下有时间再写一篇文章细谈，现在谈谈二分查找，建议大家先自己写写，然后再看下面的文章，效果更好。

让我们先看看一个朴素版的二分查找（其实也不算太朴素，不过因为这部分网上以及编程之美里都有详细描述以及代码实现，所以也就显得比较朴素了，注意事项会在代码注释里说明）：

[cpp]view plaincopy 
    
 /* 
 最朴素的二分查找：找数组a的下标s到下标e查找元素t  
 */  
 #include<stdio.h>  
   
 int binarySearch(int a[],int s,int e,int t) {  
     int i = s,j = e,mid;  
     while(i <= j) {  
      /*  
     （1）写成(i+j)/2，可能会导致求和中间结果的溢出，因为两个32位整数的和是有可能超过32位整数的范围的嘛  
     （2）因为四则运算符的优先级高于移位运算符>>，所以可以把mid = i+((j-i)>>1)简化下，不过注意不要写成mid = i+(j-i)>>1哈  
     （3）因为移位运算符比直接除快嘛，所以用>>1代替除2  
     */  
         mid = i+(j-i>>1);//(i+j)/2，写成这样可能会溢出   
         if(a[mid] == t) {  
             return mid;  
         } else {  
             if(a[mid] > t) {  
                 j = mid-1;  
             } else {  
                 i = mid+1;  
             }  
         }  
     }  
     return -1;        
 }  
   
 int main() {  
     int a[10] = {1,3,5,6,7,8,9,12,13,14};  
     int t;  
     if((t = binarySearch(a,0,9,7)) == -1) {  
         printf("不存在\n");  
     } else {  
         printf("存在,下标为%d\n",t);  
     }  
 }  

上面的代码还有什么问题呢？大家可以先想想，再往下看哈。

显然如果要查找的数在数组中存在着重复元素，而且我们还想返回该数的最小或最大下标，显然上面的程序是无法做到的，因为它一旦找到一个满足的就退出了。

下面我们来想想怎么解决这个问题。最容易想到的办法就是在数组中找到某一个数后，直接不断循环减(加)，来寻找满足条件的最小下标(最大下标)。相应代码如下：

[cpp]view plaincopy 
    
 #include<stdio.h>  
   
 int binarySearch(int a[],int s,int e,int t) {  
     int i = s,j = e,mid;  
     while(i <= j) {  
         mid = i+(j-i>>1);  
         if(a[mid] == t) {//关键部分代码(查找数组中等于t的数的最小下标，最大下标同理)  
             while(a[--mid] == t) {  
                   
             }  
             return mid+1;  
         } else {  
             if(a[mid] > t) {  
                 j = mid-1;  
             } else {  
                 i = mid+1;  
             }  
         }  
     }  
     return -1;        
 }  
   
 int main() {  
     int a[10] = {1,3,5,9,9,9,9,12,13,14};  
     int t;  
     if((t = binarySearch(a,0,9,9)) == -1) {  
         printf("不存在\n");  
     } else {  
         printf("存在,下标为%d\n",t);  
     }  
 }  

现在可以想想上面的代码存在什么问题吗？

显然如果重复的元素过多，二分查找搞不好就直接退化成暴力查找了，所以是不太好的。大家可以自己先写写解决代码。

然后后看下面代码：

[cpp]view plaincopy 
    
 #include<stdio.h>  
   
 int binarySearch(int a[],int s,int e,int t) {  
     int i = s,j = e,mid;  
     while(i < j) {  
         mid = i+(j-i>>1);  
         if(a[mid] >= t) {//关键点：并不是等于就直接退出循环  
             j = mid;  
         } else {  
             i = mid+1;  
         }  
     }  
     if(a[i] == t) {  
         return i;   
     } else {  
         return -1;    
     }         
 }  
   
 int main() {  
     int a[10] = {1,3,9,9,9,9,9,9,13,14};  
     int t;  
     if((t = binarySearch(a,0,9,9)) == -1) {  
         printf("不存在\n");  
     } else {  
         printf("存在,下标为%d\n",t);  
     }  
 }  

下面代码是找最大下标的：

[cpp]view plaincopy 
    
 /* 
 在一个非递减数组中(就是数组中存在相等的元素)，用二分查找求 
 最大的下标i，使得a[i] = t，存在返回下标i，不存在返回-1  
 */   
 #include<stdio.h>  
   
 int binarySearch(int a[],int s,int e,int t) {  
     int i = s,j = e,mid;  
     while(i < j) {  
         mid = i+(j-i+1>>1);  
         if(t >= a[mid]) {//关键点：并不是等于就直接退出循环 i = mid  
             i = mid;  
         } else {  
             j = mid-1;  
         }  
     }  
     if(a[i] == t) {  
         return i;   
     } else {  
         return -1;    
     }         
 }  
   
 int main() {  
     int a[10] = {1,9,9,9,9,9,9,12,13,14};  
     int t;  
     if((t = binarySearch(a,0,9,9)) == -1) {  
         printf("不存在\n");  
     } else {  
         printf("存在,下标为%d\n",t);  
     }  
 }  

下面我们再来思考两个类似问题，加深理解。

在一个非递减数组中(就是数组中可能存在相等的元素)，求最小的下标i，使得a[i] > t，存在返回下标i，不存在返回-1。

实现代码如下：

[cpp]view plaincopy 
    
 /* 
 在一个非递减数组中(就是数组中存在相等的元素)，用二分查找求 
 最小的下标i，使得a[i] > t，存在返回下标i，不存在返回-1  
 */   
 #include<stdio.h>  
   
 int binarySearch(int a[],int s,int e,int t) {  
     int i = s,j = e,mid;  
     while(i < j) {  
         mid = i+(j-i>>1);  
         if(t >= a[mid]) {  
             i = mid+1;  
         } else {  
             j = mid;  
         }  
     }  
     if(a[i] > t) {  
         return i;   
     } else {  
         return -1;    
     }         
 }  
   
 int main() {  
     int a[10] = {1,9,9,9,9,9,9,12,13,14};  
     int t;  
     if((t = binarySearch(a,0,9,8)) == -1) {  
         printf("不存在\n");  
     } else {  
         printf("存在,下标为%d\n",t);  
     }  
 }   

另一个类似问题：

在一个非递减数组中(就是数组中可能存在相等的元素)，求最大的下标i，使得a[i] < t，存在返回下标i，不存在返回-1。

实现代码如下：

[cpp]view plaincopy 
    
 /* 
 在一个非递减数组中(就是数组中存在相等的元素)，用二分查找求 
 最大的下标i，使得a[i] < t，存在返回下标i，不存在返回-1  
 */   
 #include<stdio.h>  
   
 int binarySearch(int a[],int s,int e,int t) {  
     int i = s,j = e,mid;  
     while(i < j) {  
         mid = i+(j-i+1>>1);//j-i>>1改成了j-i+1>>1，避免出现t比s~e区间内所有元素都大时，跳不出循环的bug<span style="font-family: Arial, Helvetica, sans-serif;">  
 </span>     if(t <= a[mid]) {  
             j = mid-1;  
         } else {  
             i = mid;  
         }  
     }  
     if(a[i] < t) {  
         return i;   
     } else {  
         return -1;    
     }         
 }  
   
 int main() {  
     int a[10] = {1,9,9,9,9,9,9,12,13,14};  
     int t;  
     if((t = binarySearch(a,0,9,10)) == -1) {  
         printf("不存在\n");  
     } else {  
         printf("存在,下标为%d\n",t);  
     }  
 }  

如果把上面两个问题改成下面这样：

1.在一个非递减数组中(就是数组中存在相等的元素)，求最**大**的下标i，使得a[i] **>** t，存在返回下标i，不存在返回-1。

2.在一个非递减数组中(就是数组中存在相等的元素)，求最**小**的下标i，使得a[i] **<** t，存在返回下标i，不存在返回-1。

大家稍微想下应该能发现这种问题意义不大，我这里就不细说了。

注：上面代码都是自己写的，如果有bug欢迎指出。上面说的一些问题如果有错误也欢迎指出，谢谢。

补充Java写的一个递归实现代码：

[java]view plaincopy 
    
 //递归实现  
 public void binarySearch(int[] a, int x, int beginIndex, int endIndex) {  
     int len = endIndex - beginIndex + 1;  
     if (endIndex < beginIndex) {//防止进入无限递归  
         System.out.println("not find");  
         return;  
     }  
     if (a[beginIndex + len / 2] == x) {  
         System.out.println("find index is:" + (beginIndex + len / 2));  
         return;  
     } else {  
         if (x > a[beginIndex + len / 2]) {  
             binarySearch(a, x, beginIndex + len / 2 + 1, endIndex);  
         } else {  
             binarySearch(a, x, beginIndex, beginIndex + len / 2 - 1);  
         }  
     }  
 }  