二分查找的几点思考

原文：http://blog.csdn.net/hexinuaa/article/details/6600885

二分查找的几点思考

很早听说90%的程序员写不出正确的二分查找程序，对此颇为怀疑也颇为惶恐。怀疑的是，二分查找真的很难写吗？惶恐的是，怀疑的我能否在短时间内写出一个正确的二分查找程序？为了自己能成为10%中的一员，在此特别总结了二分查找算法。

二分查找又称折半查找，用于在有序序列中快速寻找一个值。它始终维护一个子序列[low, high]，这个子序列可能包含目标值v。初始，这个子序列是整个序列[0, size-1], 每次取序列的中间值A[mid](其中，mid = low + (high-low)/2)与目标值v比较，因为序列是有序的，所以，每次都可以根据比较结果, 抛弃一半的序列。递归这个过程，直到找到目标值v或序列为空。

二分查找可以用递归实现，人们一般把二分查找写成非递归的。

程序1.1

int binary_search(int A[], int size,int v)

{

    int mid, low, high;

    low = 0; high = size - 1;

    while (low <= high) {

       mid = low + (high-low)/2; ①    //avoid overflow

       if(A[mid] == v)

           return mid;

       elseif(A[mid] < v)

           low = mid+1;

       else

           high = mid-1;

    }

    return -1;

}

上述程序无需多解释了，①处没有写成mid = (low+high)/2;是为了避免整数溢出，当low和high较大时，low和high本身没有溢出，而low+high有可能溢出。

下面提一个有趣的问题：如果数组中有多个元素都是v，上面的函数返回的是哪一个的下标呢？第一个？最后一个？都不是。有时，我们想确定数组A[0…size-1]中v第一次出现的位置。那应该如何编写程序呢？

程序1.2

int binary_search_lb(int A[], int size,int v)

{

    int mid, low, high;

    low = 0; high = size - 1;

    while(low < high) {

       mid = low + (high-low)/2;

       if(A[mid] >= v) high = mid; ①

       else   low = mid + 1;    ②

    }

    //确认是否存在v

    if(A[low] == v) return low;

    elsereturn -1;

}

A[mid]和v的各种关系所带来的影响如下：

A[mid]=v : 至少已经找到一个，而左边可能还有，因此区间[low, mid];

A[mid]>v : 所求位置不可能在后面，本应该让high = mid-1;但是，令区间为[low, mid]也是没有问题的;

A[mid]<v : m和前面都不可行，因此区间变为[m+1, high]

while(low < high), 都与之前的二分查处程序不一样了。当只有一个元素（low=high）的时候，退出循环，最后仍要判断A[low]是否为v，有的话low就是等v的最小下标，没有的话返回-1； 

其实，二分查找不仅可以用来查找某个元素的存在，通常还用来寻找解空间中满足某个条件的下界。这个条件或者说断言p，通常具有如下性质：

若 p(x)成立，对于所有的y>x, p(y)都成立。当然，若p(x) 不成立，所有y < x, p(y)都不成立。

就拿上个例子为例，换个说法就是，给定有序数组A[0…size-1]，寻找首个满足>=v条件的元素下标。因为数组是有序的，当某个元素值A[i]>=v时，后续的所有元素都满足>=v的条件。

假设数组A如下：

0

5

13

19

22

41

55

68

72

81

98

解空间就是下标的集合:

0

1

2

3

4

5

6

7

8

9

10

目标值v= 55时， 断言的满足情况如下：

no

no

no

no

no

no

yes

yes

yes

yes

yes

我们如何写二分查找程序，寻找第一个yes所在的下标呢?程序和上面的是类似的。

如果没有yes存在，通常，我们返回一个不存在的标志。但这里，我们假想A[size]这个哨兵一定是满足条件的，可以把它看成是个无穷大的数，它一定大于v，当没有元素大于等于v时，我们返回size。程序如下：

程序1.3

int binary_search_lb(int A[], int size,int v)

{

    int mid, low, high;

    low = 0; high = size;

    while(low < high) {

       mid = low + (high-low)/2;

       if(A[mid] >= v) high = mid; ①

       else   low = mid + 1;    ②

    }

    return low;

}

寻找第一个yes，更通用的程序架构如下：

程序1.4

binary_search(low, high, p):

   while low < high

          mid = low + (high-low)/2

          if p(mid) == true:

                high = mid

          else:

                low = mid+1

   if p(low) == false:

           complain                // p(x) is false for all x in S!

    return low         // lo is the least x for which p(x) is true

分析：

当p(mid) =true时，mid是解，左边可能还有，区间为[low, mid]。

当p(mid)=false, 解不可能在mid的前面，包括mid，区间为[mid+1, high]。

 

如何求不满足条件的最后一个no呢？程序框架如下：

程序1.5

// warning: there is a nasty bug in this snippet!

binary_search(low, high, p):

   while low < high:

      mid = low + (high-low)/2    // note: division truncates

      if p(mid) == true:

         high = mid-1

      else:

         low = mid

   if p(low) == true:

      complain                // p(x) is true for all x in S!

   return low         // lo is the greatest x for which p(x) is false

但是这个程序有问题，当只剩两个解，且第一个解是no时，程序陷入死循环。

no

yes

解决方法是将mid = low + (high-low)/2改为mid = low + (high-low+1)/2。这样的话，当元素个数大于等于2个时，low<mid<=high, mid -1 < high，区间不会和上次重复，每次范围都会缩小，直到元素个数为1，所以不会陷入死循环。

例题1：

给出n个整数xi和m个询问，对于每个询问（a，b），输出闭区间[a, b]内的整数xi的个数。

有了前面的经验，我们知道“把数据存在数组A里并排序”是一个很好的预处理方法。

问题1： 大于等于a的第一个元素的下标L是什么？它等于a的lower_bound（下界）。如果所有元素都小于a，L = size,相当于把不存在的元素看作无穷大。

问题2： 小于等于b的最后一个元素的“下一个目标”R，或者说大于b的第一个目标R是什么？它和问题2是一样的，都是first yes问题。

这样问题的答案就是区间[L,R]的长度，R-L。

求上界的程序，只需要在程序1.3的基础上将>=v改为>v即可。

 

程序1.6

int binary_search_ub(int A[], int size,int v)

{

    int mid, low, high;

    low = 0; high = size;

    while(low < high) {

       mid = low + (high-low)/2;

       if(A[mid] > v) high = mid; 

       else   low = mid + 1;   

    }

    return low;

}

例题2：把一个包含n个正整数的序列划分成m个连续的子序列（每个正整数恰好属于一个序列）。设第i个序列的各数之和为S(i),你的任务是让所有S(i)的最大值尽量小。例如序列1 2 3 2 5 4 划分成3个序列的最优方案为1 2 3| 2 5| 4，其中S(1)、S(2)，S(3)分别为6、7、4最大值为7；如果划分成1 2 |3 2| 5 4， 则最大值为9，不如刚才好。n <= 10⁶，所有数之和不超过10⁹。

分析： 我们考虑一个新的问题：能否把输入序列划分成m个连续的子序列，使得所有S(i)均不超过x？我们把这个问题的答案用微词P（x）表示，则让P(x)为真的最小x就是原题的答案。P（x）并不难计算尽量往右划分即可。P(x)满足二分查找的条件，解空间对于的P(x)值是 no no no … yes yes yes … yes的形式。寻找first yes即可，时间复杂度为O(nlogM)，M是所有数的和。

step1： 找到数组中和的最大值max（所有元素相加），最小值min（数组中最小值）。

step2： 在 min~max 这个范围内做二分查找。 找到其中使得条件成立（所有子序列和都小于这个数）的最小元素。

看了下面代码就明白了。

#include<iostream>
#include <ctime>
usingnamespace std;
#define N 10
#define INF 1000

int juge(int a[],int mid,int k)
{
	int i;
	int seg=0;
	int sum=0;
	for(i=0;i<N;i++)
	{
		sum+=a[i];
		if(sum>mid)//从左到右将数组元素之和与mid比较，如是大于则再起一段，最后看段的大小
		{
			sum=a[i];
			seg++;
		}
	}
	if(seg>=k)//若是段超过3，则必然不和条件
		return0;
	else
		return1;
}

int value(int a[],int low,int high,int segment)//分治法求解
{
	if(low>high)
		return high+1;
	else
	{
		int mid=(low+high)/2;
		if(juge(a,mid,segment)==1)//如果试验数mid符合要求，递归到前一半
			return value(a,low,mid-1,segment);
		else//如果试验数mid不符合要求，递归到后一半
			return value(a,mid+1,high,segment);
	}
}

int main()
{
	srand((unsigned)time(NULL));
	int a[N];
	for(int ifor=0;ifor<N;ifor++)
		a[ifor]=rand()%20;
	for(ifor=0;ifor<N;ifor++)
		cout<<a[ifor]<<"";

	//int a[N]={9,19,15,13,13,9,14,1,1,7};
	int m=3;
	cout<<endl;
	//求出队列中所有数的和max，还要求出当中最小的数min
	int min=INF,max=0;
	for(int i=0;i<N&& a[i]!='';i++)
	{
		max+=a[i];
		if(a[i]<min)
			min=a[i];
	}
	cout<<endl;
	int tem=value(a,min,max,m);//调用value函数求值
	cout<<tem<<endl;

	return0;
}