二分查找(Binary Search) 常见问题解决方法总结

缘由

今天浏览 何登成的技术博客  无意中发现了写的blog，二分查找(Binary Search)需要注意的问题，以及在数据库内核中的实现。

随想总结下二分查找的常见问题。

问题背景

今年的实习生招聘考试，我出了一道二分查找(Binary Search)的题目。题目大意如下：

给定一个升序排列的自然数数组，数组中包含重复数字，例如：[1,2,2,3,4,4,4,5,6,7,7]。

问题：给定任意自然数，对数组进行二分查找，返回数组正确的位置，给出函数实现。

注：连续相同的数字，返回第一个匹配位置还是最后一个匹配位置，由函数传入参数决定。

 在这片博客中作者也详细说明了，二分查找的重要性，比如在数据库的内核实现中，二分查找是一个非常重要的逻辑，几乎99%以上的

SQL语句(所有索引上的范围扫描/等值查询/Unique查询等)，都会使用到二分查找进行数据的定位。 可以看到二分查找在现实的重要性。

二分查找算法的思想

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

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

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

所以如果是用 链表存储的，就无法在其上应用 二分查找法了。

其实二分查找算法的思想很简单，在《编程珠玑》一书中的描述：

 在一个包含x的数组内，二分查找通过对范围的跟综来解决问题。开始时，范围就是整个数组。通过将范围中间的元素

与x比较并丢弃一半范围，范围就被缩小。这个过程一直持续，直到在x被发现，或者那个能够包含t的范围已成为空。

 Donald Knuth在他的《Sorting and Searching》一书中指出，尽管第一个二分查找算法早在1946年就被发表，但第一个

没有bug的二分查找算法却是在12年后才被发表出来。

注意中间值下标的计算，如果写成(low+high)/2，low+high可能会溢出，从而导致数组访问出错。改进的方法是将计算方式

写成如下形式：low+ ( (high-low) >>1)。

常见问题解决

在何登成的技术博客中的问题四 “如何查找第一个/最后一个等值”，这个大牛只是简单的说明了下，并没有详细说明怎么解决

这个问题，下面来探讨 怎么解决 当所给有序重复数组 中查找 某个值出现的 第一个 和最后一个位置。

主要是下面三个问题：

1）二分查找元素x的下标，如无 return  -1

2）二分查找返回x(可能有重复)第一次出现的下标，如无return  -1

3）二分查找返回x(可能有重复)最后一次出现的下标，如无return  -1

对于问题1 我们只需要 利用最原始的的二分查找即可。

代码如下：

/* 
bin_search 二分查找元素x的下标，如无 return -1
low,high 分别为待查元素的区间的 上下界(包含边界).
x为待查元素.
注意 low <= high 
*/
int bin_search(int *a, int low, int high, int x)
{
	if(NULL == a || low > high || low <0)
		return -1;

	int mid;
	while(low<=high)//注意是<=，若是<会找不到边界值情况
	{
		mid = low + ((high-low)>>1);
		if(x<a[mid])
			high = mid-1;
		else if(x>a[mid])
			low = mid +1;
		else
			return mid;
	}
	return -1;
}

对于问题2，二分查找返回x(可能有重复 )第一次出现的下标，如无return  -1。

我们只需找到x重复出现情况下的第一次出现的下标。则我们只需用a[mid]和元素x进行比较，当a[mid]<x时

此时待查元素肯定在待查区间的右半部分 显然此时 不包括 mid 所以有 low = mid+1, 若a[mid]>=x时, 因为我

们查找的是x第一次出现的位置,我们不关心x最后出现的位置,所以此时high下标为mid,直到 low == high 终止

循环，并且比较a[low]是否为x,若是则 找到。

总的思路是：

把有序序列分成2个序列:[first,mid][mid+1,last) 当 a[mid]<x 时 使用 使用序列[mid + 1,last)

当 a[mid]>=x 时 使用序列[first,mid]。

还是看代码吧。

/* 
binS_first二分查找返回x(可能有重复)第一次出现的下标，如无return -1
low,high 分别为待查元素的区间的 上下界(包含边界).
//分成2个序列:[first,mid][mid+1,last)
  x为待查元素.注意 循环结束条件，low == high */
int binS_first(int *a, int low, int high, int x)
{
    if(NULL == a || low > high || low <0) return -1;
    int mid;
    while(low<high)
    {
        mid=low+((high-low)>>1);//计算中点
        if(a[mid]<x)// <x ,调整起点或者终点
            low=mid+1;
        else // >=x
            high=mid;
    }
    if(a[low] == x)
        return low;
    return -1;
}

 

对于问题3，二分查找返回x(可能有重复)最后一次出现的下标，如无return  -1

其实和问题2的思路差不多。

只是在 while中我们假定 low+1 < high,否则在只有两个或者一个元素时 我们只需在while循环之外判断即可。

接下来的while 情况和问题2等价。我们现在关心的是 x(可能有重复)最后一次出现的下标，所以现在我们不关心他

第一次出现下标的位置, 当 a[mid]<=x 时 low = mid, 否则 a[mid] >x 此时 high = mid -1. 代码如下：

/* 
binS_last二分查找返回x(可能有重复)最后一次出现的下标,如无return -1
low,high 分别为待查元素的区间的 上下界(包含边界).
x为待查元素.
注意 循环结束条件，low+1 == high 
*/
int binS_last(int *a, int low, int high, int x)  
{  
	if(NULL == a || low > high || low < 0 )
		return -1;
	int mid;    
	while(low+1<high)//**   
	{  
		mid=low+((high-low)>>1);  
		if(a[mid]<=x)  // <=x
			low = mid;  
		else  // >x
			high=mid-1;  
	}  
	if(a[high] == x)//先判断high
		return high;
	else if(a[low] == x)
		return low;
	return -1;
}  

查找重复元素出现的第一次 最后一次位置总结如下：

二分查找返回x(可能有重复)第一次(最后一次)出现的下标找最小的等号放>=x位置(high),找最大的等号放<=x的位置(low)。
其中a[mid]在和待查找元素x比较中带 = 的，在对low 或者high赋值时一定为 mid，其它情况(<或>)则为mid+(-)1.

总的测试程序。

#include <stdio.h>
/*
bin_search 二分查找元素x的下标，如无 return -1
low,high 分别为待查元素的区间的 上下界(包含边界).
x为待查元素.
注意 low <= high
*/
int bin_search(int *a, int low, int high, int x)
{
    if(NULL == a || low > high || low < 0 )
        return -1;

    int mid;
    while(low<=high)//注意是<=，若是<会找不到边界值情况
    {
        mid = low + ((high-low)>>1);
        if(x<a[mid])
            high = mid-1;
        else if(x>a[mid])
            low = mid +1;
        else
            return mid;
    }
    return -1;
}
/*
binS_first二分查找返回x(可能有重复)第一次出现的下标,如无return -1
low,high 分别为待查元素的区间的 上下界(包含边界).
//分成2个序列:[first,mid][mid+1,last)
x为待查元素.
注意 循环结束条件，low == high */
int binS_first(int *a, int low, int high, int x)
{
    if(NULL == a || low > high || low < 0 )return -1;
    int mid;
    while(low<high)//<
    {
        mid=low+((high-low)>>1);
        if(a[mid]<x)// <x
            low=mid+1;
        else // >=x
            high=mid;
    }
    if(a[low] == x)
        return low;
    return -1;
}
/*
binS_last二分查找返回x(可能有重复)最后一次出现的下标,
如无return -1
low,high 分别为待查元素的区间的 上下界(包含边界).
x为待查元素.注意 循环结束条件，low+1 == high */
int binS_last(int *a, int low, int high, int x)
{
    if(NULL == a || low > high || low < 0)
        return -1;
    int mid;
    while(low+1<high)//**
    {
        mid=low+((high-low)>>1);
        if(a[mid]<=x) // <=x
            low = mid;
        else // >x
            high=mid-1;
    }
    if(a[high] == x)//先判断high
        return high;
    else if(a[low] ==x)return low;
    return -1;
}
int main()
{
    int a[]= {-1,1,2,2,2,4,4,4,4,4,4,4}; //0-11
    printf("-1: %d\n", bin_search(a, 0, 11, -1));
    printf(" 4 fisrt: %d\n", binS_first(a, 0, 11, 4));
    printf(" 4 last: %d\n", binS_last(a, 0, 11, 4));
    printf("\n");
    int b[]= {-2,-2,0,5,5,7,7}; //0-6
    printf("-2 fisrt: %d\n", binS_first(b, 0, 6, -2));
    printf("-2 last: %d\n", binS_last(b, 0, 6, -2));
    printf(" 5 fisrt: %d\n", binS_first(b, 0, 6, 5));
    printf(" 5 last: %d\n", binS_last(b, 0, 6, 5));
    return 0;
}

运行结果截图：

                    

此外对于像，二分查找返回刚好小于x的元素下标，二分查找返回刚好大于x的元素下标， 返回有序数列某一个元素重复出现的次数等问题，可以根据上面

的寻找重复元素出现第一次 最后一次位置的方法 进行 问题求解。对于这类问题也可以参考 STL 中关于 lower_bound与upper_bound的实现。STL算法库

中已经有相关实现。

参考：

http://hedengcheng.com/?p=595

编程珠玑