关于二分查找及其上下界问题的一些思考

个人认为在编程的时候,我的代码能力应该是到位的,但是昨天参加的某公司笔试彻底把这个想法给终结了,才意识到自己是多么的弱。其中印象最深刻的是一道关于二分查找上下界的问题。当时洋洋得意,STL 分分钟搞定,结果到了面试的时候他要我自己重新实现一下。这个时候就拙计了,拿着笔的我是写了改改了写,最后勉强算是完成。

今天反思一下,决定自己再把二分查找重新实现一下。也作为给自己的一个警醒,不要总以为自己能力有多高,总有一天会被打脸的。

一、二分查找思想(参照《算法竞赛入门经典》,感谢刘老师)。

在有序表中查找元素常常使用二分查找(Binary Search),有时也译为折半查找,它的基本思想就像是“猜数字游戏”:你在心里想一个不超过1000的正整数,我可以保证在10次以内猜到它—–只要你每次告诉我猜的数比你想的大一些、小一些,或者正好猜中。

猜的方法就是二分。首先我猜500,除了运气特别好正好猜中外,不管你说“太大”还是“太小”,我都可以把可行范围缩小一半:如果“太大”,那么答案在1~499之间,那我下一次猜250;如果“太小”,那么答案在501~1000之间,那我下一次猜750。只要每次选择可行区间的中间点去猜,每次都可以把范围缩小一半。由于log21000 < 10,10次内一定能猜到。

二、STL二分查找

在STL中<algorithm>中已经有二分查找的实现了。我在这里只给简单的应用,也希望读者多去了解一下STL的强大。下面的讲解参照C++ Reference,有兴趣看英文原文的戳链接。

1、binary_search()函数

该函数功能是查看某一值在一个已经排好序的序列中是否存在,当存在时返回true,否则返回false。其函数原型如下:

//default (1)    
template <class ForwardIterator, class T>
  bool binary_search (ForwardIterator first, ForwardIterator last,
                      const T& val);
//custom (2)    
template <class ForwardIterator, class T, class Compare>
  bool binary_search (ForwardIterator first, ForwardIterator last,
                      const T& val, Compare comp);

注意序列是迭代器表示,原则上可以代入多种数据类型。其中几个参数如下:

first:序列需要查询的开始位置;

last:序列需要查询的结束位置;

val:需要查询的元素;

comp:用户自定义比较函数。

注意到default(1)和custom(2)的区别在于用户有没有自定义比较函数。对于default(1)版本,使用运算符 “<” 进行元素间的比较;对于custom(2),使用用户自定义comp进行元素间比较。

也就是说,binary_search()函数是在序列区间[first, last)中查找是否有某一元素。其中序列一定要先排好序,排序比较函数必须和二分查找比较函数相同。

2、lower_bound()函数

binary_search()只能告诉我们元素在序列中是否存在,却无法定位它的确切位置。并且有时候所给的序列不一定是每个元素都不同的,同值的元素可能多次出现(因为已经排好序,所以相同的元素是相邻的)。如果我们需要找到这些相同的元素中的第一个怎么办?

其实还STL中还定义了lower_bound()函数来解决这个问题,其函数原型如下:

//default (1)    
template <class ForwardIterator, class T>
  ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,
                               const T& val);
//custom (2)    
template <class ForwardIterator, class T, class Compare>
  ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,
                               const T& val, Compare comp);

这个函数的参数和binary_search()函数是相同的,我就不再赘述,但是它的返回类型是ForwardIterator,又见迭代器,为什么不按照我们的要求返回一个整型值表示下表呢?这个我也不解,不过没关系,我们照样能得到我们想要的答案。

也就是说,这个函数的功能是返回迭代器的下界。

确切的说:如果所要查找的元素只有一个,那么lower_lound()返回了这个元素的地址(注意这里是地址,不是下标);

如果所要查找的元素有多个相同,因为他们相邻,所以可以用一个区间表示[first, last)(左闭右开)它们的位置,那么lower_bound()函数返回的就是first的地址(再次强调是地址)。

3、upper_bound()函数

举一反一,我们大概知道upper_bound()函数是干嘛的了吧,那就是返回迭代器上界,也就是所查找元素的区间的上界,但是和lower_bound()略有不同。

其函数原型如下:

//default (1)    
template <class ForwardIterator, class T>
  ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last,
                               const T& val);
//custom (2)    
template <class ForwardIterator, class T, class Compare>
  ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last,
                               const T& val, Compare comp);

注意我们之前有强调过,表示相同元素的区间[first, last)是左闭右开的,为什么要这样子?我不知道,你去问问写这套STL的人吧,我不敢黑他。这就造成了lower_bound()和upper_bound()的一个不同之处。那就是:lower_bound()可以相等,upper_bound()不能相等。

更加详细:如果元素只出现一次,那么lower_bound()找到了这个元素的地址,但是upper_bound()找到的却是它的下一个;

如果相同元素出现了多次,那么lower_bound()找到了第一个所找元素的地址,但是upper_bound()找到的却是最后一个元素的下一个元素的地址。

4、简单例子测试。

知道上面的三个函数的使用方法了,那么我们来具体操作一下:

测试代码如下:

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

int main()
{
    int a[] = {0, 0, 2, 2, 2, 4, 4, 4, 4, 5};
    int val;
    while(1)
    {
        printf(“请输入需要查找的数:”);
        scanf(“%d”, &val);
        if(binary_search(a, a+10, val) == false)
            printf(“未找到数 %d,请重新输入!\n\n”, val);
        else
        {
            printf(“数 %d 已找到!\n”, val);
            printf(“相同个数: %d\n”, upper_bound(a, a+10, val)-lower_bound(a, a+10, val));
            printf(“下界为:   %d\n”, lower_bound(a, a+10, val));
            printf(“上界为:   %d\n\n”, upper_bound(a, a+10, val));
        }
    }
    return 0;
}

当然上面的是三个函数最简单的应用了,为了让大家看得更清楚,读者不要喷我一个函数写了多次。我们可以查看所找元素是否存在,它第一次出现的位置和最后一次出现的位置,同时我们看知道了上下界就可以求出该元素出现了多少次。但是,我们看测试结果:

对,我们没有看错,这个上下界是地址。就拿2来看,上界减下界等于12,一个int型占用4个字节,那么2的个数为3个。但是,我们要地址干什么?没有用啊!

别着急,想得到下标还不简单。稍稍修改一下:

    printf("下界为:   %d\n", lower_bound(a, a+10, val)-a);     //减去首地址,就找到了下标位置
    printf("上界为:   %d\n", upper_bound(a, a+10, val)-a);   //同上
    printf("该元素所在范围: [%d, %d)\n\n", lower_bound(a, a+10, val)-a, upper_bound(a, a+10, val)-a);

程序运行结果如图:

至此,STL二分查找的三个函数大致介绍完成,还有另外的几个函数读者有兴趣可以上C++ Reference去挖掘一下。

三、手动实现二分查找三个函数。

本来今天的重点应该放在我是怎么实现上的,不知道怎么就跑偏了。其实讲了思想,大家应该可以着手写代码了。不同人有不同人实现的方法,其中的技巧还是有不少的。下面给处我个人的实现,如果有人能挑出其中的缺陷,欢迎点评。

1、binary_search()函数

STL的binary_search()返回的是bool值,不过一般算法书或者数据结构书上都是这样阐述的:若找到,输出它的下标,若未找到,输出-1。

下面呢,是我的简单实现,功能如上所述:

#include <iostream>
#include <cstdio>
using namespace std;

int binary_search_1(int* A, int l, int r, int val)    //A为序列,l为左边界,r为右边界,val是元素
{
    //cout << l << " " << r << endl;
    if(l > r) return -1;                    //左边界严格不大于右边界,否则说明找不到
    int mid = l+(r-l)/2;                    //从中剖分,注意这里的一个小技巧,为何不用(l+r)/2,读者可以去思考,下面函数的注释会给出解答。
    if(A[mid] == val) return mid;           //如果找到,返回
    if(A[mid] > val) r = mid-1;       //否则,修改边界
    else l = mid+1;
    return binary_search_1(A, l, r, val);     //递归调用
}
int main()
{
    int a[] = {0, 0, 2, 2, 2, 4, 4, 4, 4, 5};
    cout << binary_search_1(a, 0, 10, 2);  //a为数组,0为起始位置,9为结束位置,表明你要查找的特定区间,现在为0~9,2为元素
    return 0;
}

下面看非递归版的:

int binary_search_2(int* A, int l, int r, int val)    //A为序列,l为左边界,r为右边界,val是元素
{
    int mid;
    while(l < r)
    {
        mid = l+(r-l)/2;
        if(A[mid] == val) return mid;
        if(A[mid] > val) r = mid-1;
        else l = mid+1;
    }
    return -1;
}

2、lower_bound()函数和upper_bound()函数

自己实现的binary_search()在元素都互不相同的时候还挺好,但是如果存在相同元素时,那就存在不确定性,那么,它具体返回哪一个呢,这是不确定的。那么我们来实现一下lower_bound()函数,求一下它的下界,既然是自己实现,就可以把下标输出来了,规避掉地址。

代码如下,参数与binary_search()相同:

#include <iostream>
#include <cstdio>
using namespace std;

int lower_bound_1(int* A, int l, int r, int val)    //二分求下界
{
    //cout << "l and r: " << l << " " << r << endl;
    if(l > r) return -1;
    if(A[l] == val) return l;
    int mid = l+(r-l)/2;         //注意这里是l+(r-l)/2,当l+r是奇数时,mid它是更靠近l
    if(A[mid] > val) r = mid-1;
    else if( A[mid] == val) r = mid;
    else l = mid+1;
    return lower_bound_1(A, l, r, val);     //递归调用
}

int upper_bound_1(int* A, int l, int r, int val)    //二分求上界
{
    //cout << "l and r: " << l << " " << r << endl;
    if(l > r) return -1;
    if(A[r] == val) return r;
    int mid = l+(r-l+1)/2;      //注意这里是l+(r-l+1)/2,当l+r是奇数时,mid它是更靠近r
    if(A[mid] > val) r = mid-1;
    else if( A[mid] == val) l = mid;
    else l = mid+1;
    return upper_bound_1(A, l, r, val);     //递归调用
}

int main()
{
    int a[] = {0, 0, 2, 2, 2, 4, 4, 4, 4, 5};
    printf("lower_bound at %d\n", lower_bound_1(a, 0, 9, 4));
    printf("upper_bound at %d\n", upper_bound_1(a, 0, 9, 4));
    return 0;
}

非递归代码:

int lower_bound_2(int* A, int l, int r, int val) //非递归版本,参数设置三个函数都相同
{
    int mid;
    while(l < r)
    {
        mid = l+(r-l)/2;
        if(A[mid] > val) r = mid-1;
        else if(A[mid] == val) r = mid;
        else l = mid+1;
    }
    if(A[l] == val) return l;
    return -1;
}

int upper_bound_2(int* A, int l, int r, int val) //非递归版本,参数设置三个函数都相同
{
    int mid;
    while(l < r)
    {
        mid = l+(r-l+1)/2;
        if(A[mid] > val) r = mid-1;
        else if(A[mid] == val) l = mid;
        else l = mid+1;
    }
    if(A[r] == val) return r;
    return -1;
}

3、测试

自己已经在机器上测试了一遍,写测试函数好累,读者有兴趣自己测试吧。偷个懒。

四、总结

二分查找的算法效率是非常非常高的,我相信我在这里讲的应该挺详细了。下面有一道题就要用到二分的思想。

题目:

正整数数组a[0], a[1], a[2], ···, a[n-1],n可以很大,大到1000000000以上,但是数组中每个数都不超过100。现在要你求所有数的和。假设这些数已经全部读入内存,因而不用考虑读取的时间。希望你用最快的方法得到答案。

提示:二分。