【转】二分

原创：http://blog.chinaunix.net/uid-1844931-id-3337784.html

前几天在论坛上看到有统计说有80%的程序员不能够写对简单的二分法。二分法不是很简单的吗？ 这难道不是耸人听闻？ 

其实，二分法真的不那么简单，尤其是二分法的各个变种。 最最简单的二分法，就是从一个排好序的数组之查找一个key值。 如下面的程序：

int search(int *arr, int n, int key){
 　　int left=0, right=n-1;
     //首先要把握下面几个要点：  
     //right=n-1 => while(left <= right) => right=mid-1; 
     //right=n   => while(left <  right) => right=mid; 
     while(left<=right){
    　　int mid=left+((right-left)<<1);//防止溢出，移位也更高效。
    　　if(arr[mid]>key) right=mid-1;
    　　else if (arr[mid]<key) left=mid+1;
    　　else return mid;
        //数组中不相等的情况更多
    　　//如果每次循环都判断一下是否相等，将耗费时间
 　　}
 　　return -1;
}

 

这个程序，相信只要是一个合格的程序员应该都会写。 稍微注意一点， 每次移动left和right指针的时候，需要在mid的基础上+1或者-1， 防止出现死循环， 程序也就能够正确的运行。

但如果条件稍微变化一下， 你还会写吗？如，数组之中的数据可能可以重复，要求返回匹配的数据的最小（或最大）的下标；更近一步， 需要找出数组中第一个大于key的元素（也就是最小的大于key的元素的）下标，等等。 这些，虽然只有一点点的变化，实现的时候确实要更加的细心。 下面列出了这些二分检索变种的实现。

1. 找出第一个与key相等的元素

int searchFirstEqual(int *arr, int n, int key){
　　int left=0,right=n-1;
　　while(left<=right) {
　　int mid=(left+right)/2;
　　if(arr[mid]>=key) right=mid-1;
　　else if(arr[mid]<key) left=mid+1;
　　}
　　if(left<n&&arr[left]==key) return left;
　　return -1;
}

2. 找出最后一个与key相等的元素

int searchLastEqual(int *arr, int n, int key){
　　int left=0,right=n-1;
　　while(left<=right) {
　　int mid=(left+right)/2;
　　if(arr[mid]>key) right=mid-1;
　　else if(arr[mid]<=key) left=mid+1; 
　　}
　　if(right>=0&&arr[right]==key) return right;
　　return -1;
}

3. 查找第一个等于或者大于Key的元素

int searchFirstEqualOrLarger(int *arr,int n,int key){
　　int left=0, right=n-1;
　　while(left<=right) {
　　　　int mid=(left+right)/2;
　　　　if(arr[mid]>=key) right=mid-1;
　　　　else if (arr[mid]<key) left=mid+1;
　　}
　　return left;
}

4. 查找第一个大于key的元素

int searchFirstLarger(int *arr, int n, int key){
　　int left=0, right=n-1;
　　while(left<=right) {
　　　　int mid=(left+right)/2;
　　　　if(arr[mid]>key) right=mid-1;
　　　　else if (arr[mid]<=key) left=mid+1;
　　}
　　return left;
}

5. 查找最后一个等于或者小于key的元素

int searchLastEqualOrSmaller(int *arr,int n,int key){
　　int left=0,right=n-1;
　　while(left<=right) {
　　　　int m=(left+right)/2;
　　　　if(arr[m]>key) right=m-1;
　　　　else if (arr[m]<=key) left=m+1;
　　}
　　return right;
}

6. 查找最后一个小于key的元素

int searchLastSmaller(int *arr,int n,int key){
　　int left=0, right=n-1;
　　while(left<=right) {
　　　　int mid=(left+right)/2;
　　　　if(arr[mid]>=key) right=mid-1;
　　　　else if(arr[mid]<key) left=mid+1;
　　}
　　return right;
}

下面是一个测试的例子：

int main(){
　　int arr[17] = {1, 
　　　　　　　　　 2, 2, 5, 5, 5, 
　　　　　　　　　 5, 5, 5, 5, 5, 
　　　　　　　　　 5, 5, 6, 6, 7};
　　printf("First Equal : %2d \n", searchFirstEqual(arr, 16, 5));
　　printf("Last Equal : %2d \n", searchLastEqual(arr, 16, 5));
　　printf("First Equal or Larger : %2d \n", searchFirstEqualOrLarger(arr, 16, 5));
　　printf("First Larger : %2d \n", searchFirstLarger(arr, 16, 5));
　　printf("Last Equal or Smaller : %2d \n", searchLastEqualOrSmaller(arr, 16, 5));
　　printf("Last Smaller : %2d \n", searchLastSmaller(arr, 16, 5));
　　return 0;
}

最后输出结果是：

First Equal : 3
Last Equal : 12
First Equal or Larger : 3
First Larger : 13
Last Equal or Smaller : 12
Last Smaller : 2

很多的时候，应用二分检索的地方都不是直接的查找和key相等的元素，而是使用上面提到的二分检索的各个变种，熟练掌握了这些变种，当你再次使用二分检索的检索的时候就会感觉的更加的得心应手了。

 搜狗还有一道面试题目：

有一个数组，该数组的特点是：前一部分递增有序，后一部分递减有序，求数组的峰值位置。（严格先增后减）

#include <stdio.h>
//数组是先增后减数组。
int findMax(int *a ,int n){
    int low = 0,high = n-1,mid;
    while(low <= high){
        mid = low + ((high-low)>>1);
        if((mid + 1)<=high && (mid-1)>=low){
            if(a[mid] >= a[mid-1] && a[mid] >= a[mid + 1]){
                return mid;
            }else if(a[mid] >= a[mid-1] && a[mid] <=a[mid + 1]){
                low = mid + 1;
            }else{
                high = mid - 1;
            }
        }else if((mid+1) <= high){
            if(a[mid] <= a[mid+1]){
                return mid+1;
            }else{
                return mid;
            }
        }else{
            if(a[mid] <= a[mid-1]){
                return mid-1;
            }else{
                return mid;
            }
        }

    }
}

int main(){
    int a[] = {1,2,7,6,5,4,3,1};
    printf("%d \n",findMax(a,8));
}