分治算法之二分搜索--Binary

二分搜索

折半搜索，也称二分查找算法、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

时间复杂度：二分搜索每次把搜索区域减少一半，很明显时间复杂度为O(logN)。 
空间复杂度：O(1)，虽以递归形式定义，但是尾递归，可改写为循环。

二分搜索的基本实现

二分查找法在算法家族大类中属于“分治法”，分治法基本都可以用递归来实现的，二分查找法的递归实现如下：

int binary_search(int array[], int low, int high, int target){    if (low > high) return -1;        int mid = (low + high)/2;    if (array[mid]> target)        return binary_search(array, low, mid -1, target);    if (array[mid]< target)        return binary_search(array, mid+1, high, target);    return mid;}

非递归实现：

int binary_search(int array[], int low, int high, int target){    while(low <= high)    {        int mid = (low + high)/2;        if (array[mid] > target)            high = mid - 1;        else if (array[mid] < target)            low = mid + 1;        else //find the target            return mid;    }    //the array does not contain the target    return -1;}

在轮转后的有序数组上应用二分查找法

二分法是要应用在有序的数组上，如果是无序的，那么比较和二分就没有意义了。不过还有一种特殊的数组上也同样可以应用，那就是“轮转后的有序数组（Rotated Sorted Array）”。它是有序数组，取期中某一个数为轴，将其之前的所有数都轮转到数组的末尾所得。比如{7, 11, 13, 17, 2, 3, 5}就是一个轮转后的有序数组。非严格意义上讲，有序数组也属于轮转后的有序数组——取首元素作为轴进行轮转。

下边就是二分查找法在轮转后的有序数组上的实现（假设数组中不存在相同的元素）

int SearchInRotatedSortedArray(int array[], int low, int high, int target) {    while(low <= high)    {        int mid = (low + high) / 2;        if (target < array[mid])            if (array[mid] < array[high])//the higher part is sorted                high = mid - 1; //the target would only be in lower part            else //the lower part is sorted                if(target < array[low])//the target is less than all elements in low part                    low = mid + 1;                else                    high = mid - 1;        else if(array[mid] < target)            if (array[low] < array[mid])// the lower part is sorted                low = mid + 1; //the target would only be in higher part            else //the higher part is sorted               if (array[high] < target)//the target is larger than all elements in higher part                    high = mid - 1;                else                    low = mid + 1;        else //if(array[mid] == target)            return mid;    }    return -1;}

对比普通的二分查找法，为了确定目标数会落在二分后的那个部分，需要更多的判定条件。但还是实现了O(log n)的目标。

找到轮转后的有序数组中第K小的数

对于普通的有序数组来说，这个问题是非常简单的，因为数组中的第K-1个数（即A[K-1]）就是所要找的数，时间复杂度是O(1)常量。但是对于轮转后的有序数组，在不知道轮转的偏移位置，我们就没有办法快速定位第K个数了。

不过我们还是可以通过二分查找法，在log(n)的时间内找到最小数的在数组中的位置，然后通过偏移来快速定位任意第K个数。当然此处还是假设数组中没有相同的数，原排列顺序是递增排列。

在轮转后的有序数组中查找最小数的算法如下：

//return the index of the min value in the Rotated Sorted Array, whose range is [low, high]int findIndexOfMinVaule(int A[], int low, int high){    if (low > high) return -1;    while (low < high)     {        int mid = (low + high)/2;        if (A[mid] > A[high])            low = mid +1;        else            high = mid;    }        //at this point, low is equal to high    return low;}

接着基于此结果进行偏移，再基于数组长度对偏移后的值取模，就可以找到第K个数在数组中的位置了：

//return the index of the kth element in the Rotated Sorted Arrayint findKthElement(int A[], int m, int k){    if (k > m) return -1;    int base = findIndexOfMinVaule(A, 0, m-1);    int index = (base+k-1) % m;    return index;}

整数的求平方根函数

这个其实也是毕竟常见的面试问题，要求不调用math库，实现对整数的sqrt方法，返回值只需要是整数。
其实这个问题用数学的表达方式就是：对于非负整数x，找出另一个非负整数n，其中n满足 n^2 <= x < (n+1)2。
所以最直接的方法就是从0到x遍历过去直到找到满足上述条件的n。这个算法的复杂度自然是O(n)。

仔细想想，其实要找的数是在0和x之间，而他正巧可以视为一个有序的数组。似乎有可以运用二分查找法的可能。再回想二分查找法是要找到满足“与目标数相等”这一条件的数，而这里同样也是要找满足一定条件的数。所以就可以用二分法来解这个问题了，让复杂度降为O(logn)。

为方便起见，假设传入的参数是非负的整数，因此使用unsigned int。

unsigned int sqrt(unsigned int x) {    //no value should larger than max*max, otherwise it would be overflow    unsigned int max = (1 << (sizeof(x)/2*8))-1; //65535    if (max*max < x) return max;        unsigned int low = 0;    unsigned int high = max-1;        unsigned int mid = 0;    while (1)     {        mid = (low + high)/2;        if (x < mid * mid)            high = mid-1;        else if((mid+1)*(mid+1) <= x)            low = mid+1;        else //if(mid * mid <= x && x < (mid+1)*(mid+1))            break;    }        return  mid;}

题目：有一类数组，例如数组[1,2,3,4,6,8,9,4,8,11,18,19,100] 前半部分是是一个递增数组，后面一个还是递增数组，但整个数组不是递增数组，那么怎么最快的找出其中一个数？
分析：此题数组不是严格递增的数据，因为有重复的元素。对数组的前半部分和后半部分分别进行二分查找。

#include <iostream>using namespace std;//二分查找int binary_search(int* a, int low, int high, int goal){    while(low <= high)    {        int middle = low + ((high-low)>>1);        if(a[middle] == goal)            return middle;        else if(a[middle] < goal)            low = middle + 1;        else            high = middle - 1;    }    return -1;}void getNum(int *a, int len, int goal){    int i, index;    for(i = 0; i < len-1; i++)    {        if(a[i] > a[i+1])     //找到前、后两个数组的分界点            break;    }    if(a[i] >= goal)          //对前面数组进行二分查找    {        index = binary_search(a, 0, i, goal);        printf("%d\n",index);    }    if(a[i+1] <= goal)         //对后面数组进行二分查找    {        index = binary_search(a, i+1, len-1, goal);        printf("%d\n",index);    }}int main(void){    int a[]={1,2,3,4,6,8,9,4,8,11,18,19,100};    int len = 13, goal = 8;    getNum(a,len,goal);    return 0;}

Java实现的二分搜索 融合了泛型方法和比较器

public class binary_search {public static  <T> T search(T[]t,Comparator<T>comparator,T object){int min=0,max=t.length-1;int mid=(min+max)/2;if(comparator!=null){ while(min<max) {if(comparator.compare(t[mid],object)==0){return t[mid];}else if(comparator.compare(t[mid],object)<1){min=mid+1;}else{max=mid-1;}mid=(min+max)/2; }}else{Comparable<? super T>comparable  = (Comparable<? super T>)object; while(min<=max) {int cmp=comparable.compareTo(t[mid]);if(cmp==0){return t[mid];}else if(cmp>=1){min=mid+1;}else{max=mid-1;}mid=(min+max)/2; }}return null;}}