二分查找法

关于二分查找法

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

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

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

所以如果是用链表存储的，就无法在其上应用二分查找法了。（曽在面试被问二分查找法可以什么数据结构上使用：数组？链表？）

至于是顺序递增排列还是递减排列，数组中是否存在相同的元素都不要紧。不过一般情况，我们还是希望并假设数组是递增排列，数组中的元素互不相同。

二分查找法的基本实现

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

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

不过所有的递归都可以自行定义stack来解递归，所以二分查找法也可以不用递归实现，而且它的非递归实现甚至可以不用栈，因为二分的递归其实是尾递归，它不关心递归前的所有信息。

int bsearchWithoutRecursion(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;}

用二分查找法找寻边界值

之前的都是在数组中找到一个数要与目标相等，如果不存在则返回-1。我们也可以用二分查找法找寻边界值，也就是说在有序数组中找到“正好大于（小于）目标数”的那个数。

用数学的表述方式就是：

     在集合中找到一个大于（小于）目标数t的数x，使得集合中的任意数要么大于（小于）等于x，要么小于（大于）等于t。

 

举例来说：

给予数组和目标数

int array = {2, 3, 5, 7, 11, 13, 17};int target = 7;

那么上界值应该是11，因为它“刚刚好”大于7；下届值则是5，因为它“刚刚好”小于7。

用二分查找法找寻上届

//Find the fisrt element, whose value is larger than target, in a sorted array int BSearchUpperBound(int array[], int low, int high, int target){    //Array is empty or target is larger than any every element in array     if(low > high || target >= array[high]) return -1;        int mid = (low + high) / 2;    while (high > low)    {        if (array[mid] > target)            high = mid;        else            low = mid + 1;                mid = (low + high) / 2;    }    return mid;}

与精确查找不同之处在于，精确查找分成三类：大于，小于，等于（目标数）。而界限查找则分成了两类：大于和不大于。

如果当前找到的数大于目标数时，它可能就是我们要找的数，所以需要保留这个索引，也因此if (array[mid] > target)时 high=mid; 而没有减1。

用二分查找法找寻下届

//Find the last element, whose value is less than target, in a sorted array int BSearchLowerBound(int array[], int low, int high, int target){    //Array is empty or target is less than any every element in array    if(high < low  || target <= array[low]) return -1;        int mid = (low + high + 1) / 2; //make mid lean to large side    while (low < high)    {        if (array[mid] < target)            low = mid;        else            high = mid - 1;                mid = (low + high + 1) / 2;    }    return mid;}

下届寻找基本与上届相同，需要注意的是在取中间索引时，使用了向上取整。若同之前一样使用向下取整，那么当low == high-1，而array[low] 又小于 target时就会形成死循环。因为low无法往上爬超过high。

这两个实现都是找严格界限，也就是要大于或者小于。如果要找松散界限，也就是找到大于等于或者小于等于的值（即包含自身），只要对代码稍作修改就好了：

去掉判断数组边界的等号：

target >= array[high]改为 target > array[high]

在与中间值的比较中加上等号：

array[mid] > target改为array[mid] >= target

用二分查找法找寻区域

之前我们使用二分查找法时，都是基于数组中的元素各不相同。假如存在重复数据，而数组依然有序，那么我们还是可以用二分查找法判别目标数是否存在。不过，返回的index就只能是随机的重复数据中的某一个。

此时，我们会希望知道有多少个目标数存在。或者说我们希望数组的区域。

结合前面的界限查找，我们只要找到目标数的严格上届和严格下届，那么界限之间（不包括界限）的数据就是目标数的区域了。

//return type: pair<int, int>//the fisrt value indicate the begining of range,//the second value indicate the end of range.//If target is not find, (-1,-1) will be returnedpair<int, int> SearchRange(int A[], int n, int target) {    pair<int, int> r(-1, -1);    if (n <= 0) return r;        int lower = BSearchLowerBound(A, 0, n-1, target);    lower = lower + 1; //move to next element        if(A[lower] == target)        r.first = lower;    else //target is not in the array        return r;        int upper = BSearchUpperBound(A, 0, n-1, target);    upper = upper < 0? (n-1):(upper - 1); //move to previous element        //since in previous search we had check whether the target is    //in the array or not, we do not need to check it here again    r.second = upper;        return r;}

它的时间复杂度是两次二分查找所用时间的和，也就是O(log n) + O(log n)，最后还是O(log n)。

二分查找法的缺陷

二分查找法的O(log n)让它成为十分高效的算法。不过它的缺陷却也是那么明显的。就在它的限定之上：

必须有序，我们很难保证我们的数组都是有序的。当然可以在构建数组的时候进行排序，可是又落到了第二个瓶颈上：它必须是数组。

数组读取效率是O(1)，可是它的插入和删除某个元素的效率却是O(n)。因而导致构建有序数组变成低效的事情。

 

解决这些缺陷问题更好的方法应该是使用二叉查找树了，最好自然是自平衡二叉查找树了，自能高效的（O(n log n)）构建有序元素集合，又能如同二分查找法一样快速（O(log n)）的搜寻目标数。