二分查找及其几个变形

 

#include <iostream>
#include <cassert>

using namespace std;

//给定一个非降序有序数组，返回出现value的任意
//一位置，不存在则返回-1
//low：a中第一个元素的下标
//high：a中最后一个元素的下标
//如果在a中有多个value，每次返回的都是value第一次
//出现的下标
int BinarySearch1(int *a,int low,int high,int value)
{
    if (!a || low>high || value<a[low] || value>a[high])
    {
        return -1;
    }
    int middle=low;
    low--;
    high++;
    //low--最初是为了对a中只有两个元素时也能进入while循环
    //但是low--之后，middle=low+((high-low)>>1);计算得到值
    //并不是数组a的中间位置的值，为了平衡low--，所以让high++
    //这样计算得到的就是数组的中间位置的值了。high++的另外一个
    //好处就是当a中只有一个元素时，while循环也是满足的。
    while(low+1!=high)
    {
        middle=low+((high-low)>>1);
        //由于value>a[middle]的条件约束，如果找到value，那么
        //对应的下标肯定在high端，low端所对应的元素值都比value小。
        if (value>a[middle])
        {
            low=middle;
        }
        else
        {
            high=middle;
        }
    }
    //由于low+1!=high的条件约束，当high和low之间只存在两个元素时，
    //此时low对应第一个元素，high对应第二个元素，不会进入while循环
    //也就不能对high元素是否等于value进行判断。所以需要下面的if判断
    //a[high]!=value。当a中的所有元素都不要查找的元素小时
    if (a[high]!=value)
    {
        high=-1;
    }
    return high;
}


//给定一个非降序有序数组，返回出现value的最后
//一个位置，不存在则返回-1
int BinarySearch2(int *a,int low,int high,int value)
{
    if (!a || low>high || value<a[low] || value>a[high])
    {
        return -1;
    }
    int middle=low;
    low--;
    high++;
    while(low+1!=high)
    {
        middle=low+((high-low)>>1);
        //由于value<a[middle]的条件约束，如果找到value，那么
        //对应的下标肯定在low端，high端所对应的元素值都比value大。
        if (value<a[middle])
        {
            high=middle;
        }
        else
        {
            low=middle;
        }
    }
    //这里要对a[low]进行探测
    if (a[low]!=value)
    {
        low=-1;
    }
    return low;
}

//辅助方法：二分查找
//输出最小的i，使得a[i]大于value.
//如果所有a[i]均小于value，则返回
//high+1。如果出现错误返回-1
int BinarySearch3(int* a,int low,int high,int value)
{
    //边界条件检查
    if (!a || low>high)
    {
        return -1;
    }
    //下面两个if语句在while循环中都会处理这两种情况
    //之所以单独提出来，是因为这两种情况无需进入while
    //循环，直接用if语句就可以处理了。
    //if (value>elem[high])
    //{
    //    return high+1;
    //}
    //if (value<elem[low])
    //{
    //    return low;
    //}
    //这里之所以令low减1是为了这种情况考虑：
    //当high-low=1时，即只有两个元素，那么
    //while循环就不会满足，所以令low减1。
    low--;
    high++;
    int middle;
    //这里如果high的值没有改变，说明a中的所有数字都比
    //value大，那出了循环直接返回high就可以了。这个时候
    //不需要像查找value在a中是否存在那样，while执行之后
    //使用if条件判断。这里不要if判断了。
    while (low+1!=high)
    {
        middle=low+((high-low)>>1);
        if (a[middle]>value)
        {
            high=middle;
        }
        else
        {
            low=middle;
        }
    }
    return high;
}


//辅助方法：二分查找
//输出最大的i，使得a[i]小于value.
//如果所有a[i]均大于value，则返回
//low-1。如果出现错误返回-2
//因为low-1可能等于-1，所以这里用-2
//作为错误码
int BinarySearch4(int* a,int low,int high,int value)
{
    //边界条件检查
    if (!a || low>high)
    {
        return -2;
    }
    //下面两个if语句在while循环中都会处理这两种情况
    //之所以单独提出来，是因为这两种情况无需进入while
    //循环，直接用if语句就可以处理了。
    //if (value>elem[high])
    //{
    //    return high;
    //}
    //if (value<elem[low])
    //{
    //    return low-1;
    //}
    low--;
    high++;
    int middle;
    //这里如果high的值没有改变，说明a中的所有数字都比
    //value大，那出了循环直接返回high就可以了。这个时候
    //不需要像查找value在a中是否存在那样，while执行之后
    //使用if条件判断。这里不要if判断了。
    while (low+1!=high)
    {
        middle=low+((high-low)>>1);
        if (a[middle]<value)
        {
            low=middle;
        }
        else
        {
            high=middle;
        }
    }
    return low;
}

//给定一个非降序有序数组，输出最接近value
//的两个值的下标
pair<int,int> BinarySearch5(int *a,int low,int high,int value)
{
    //边界条件检查
    if (!a || low>high)
    {
        return pair<int,int>(-2,-2);
    }
    //这里之所以令low减1是为了这种情况考虑：
    //当high-low=1时，即只有两个元素，那么
    //while循环就不会满足，所以令low减1。
    low--;
    high++;
    int middle;
    //这里如果high的值没有改变，说明a中的所有数字都比
    //value大，那出了循环直接返回high就可以了。这个时候
    //不需要像查找value在a中是否存在那样，while执行之后
    //使用if条件判断。这里不要if判断了。
    while (low+1!=high)
    {
        middle=low+((high-low)>>1);
        if (a[middle]<value)
        {
            low=middle;
        }
        else
        {
            high=middle;
        }
    }
    pair<int,int> pos(high,high);
    if (a[high]!=value)
    {
        pos.first=low;
    }
    return pos;
}


int main()
{
    const int aLength=7;
    int a1[aLength]={1,2,3,4,5,6,8};
    int a2[aLength]={1,1,1,1,1,1,1};
    int a3[aLength]={1,1,2,2,2,3,3};
    int a4[aLength]={1,2,3,3,4,4,5};
    cout<<"返回value第一次出现的位置："<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch1(a1,0,aLength-1,a1[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch1(a2,0,aLength-1,a2[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch1(a3,0,aLength-1,a3[i])<<"  ";
    }
    cout<<endl;    
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch1(a4,0,aLength-1,a4[i])<<"  ";
    }
    cout<<endl;
    cout<<BinarySearch1(a1,0,aLength-1,7)<<endl;
    
    cout<<"返回value最后一次出现的位置："<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch2(a1,0,aLength-1,a1[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch2(a2,0,aLength-1,a2[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch2(a3,0,aLength-1,a3[i])<<"  ";
    }
    cout<<endl;    
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch2(a4,0,aLength-1,a4[i])<<"  ";
    }
    cout<<endl;
    cout<<BinarySearch2(a1,0,aLength-1,7)<<endl;

    cout<<"返回值大于value的最小的下标："<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch3(a1,0,aLength-1,a1[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch3(a2,0,aLength-1,a2[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch3(a3,0,aLength-1,a3[i])<<"  ";
    }
    cout<<endl;    
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch3(a4,0,aLength-1,a4[i])<<"  ";
    }
    cout<<endl;
    cout<<BinarySearch3(a1,0,aLength-1,7)<<endl;

    cout<<"返回值小于value的最大的下标："<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch4(a1,0,aLength-1,a1[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch4(a2,0,aLength-1,a2[i])<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch4(a3,0,aLength-1,a3[i])<<"  ";
    }
    cout<<endl;    
    for (int i=0;i<aLength;i++)
    {
        cout<<BinarySearch4(a4,0,aLength-1,a4[i])<<"  ";
    }
    cout<<endl;
    cout<<BinarySearch4(a1,0,aLength-1,7)<<endl;

    cout<<"返回值最接近value的两个下标,如果存在value就两个值同时为value的下标："<<endl;
    pair<int,int> pos;
    for (int i=0;i<aLength;i++)
    {
        pos=BinarySearch5(a1,0,aLength-1,a1[i]);
        cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        pos=BinarySearch5(a2,0,aLength-1,a2[i]);
        cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        pos=BinarySearch5(a3,0,aLength-1,a3[i]);
        cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    }
    cout<<endl;
    for (int i=0;i<aLength;i++)
    {
        pos=BinarySearch5(a4,0,aLength-1,a4[i]);
        cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    }
    cout<<endl;
    pos=BinarySearch5(a1,0,aLength-1,7);
    cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    int a5[aLength]={1,5,9,9,13,20,25};
    pos=BinarySearch5(a5,0,aLength-1,0);
    cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    pos=BinarySearch5(a5,0,aLength-1,4);
    cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    pos=BinarySearch5(a5,0,aLength-1,7);
    cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    pos=BinarySearch5(a5,0,aLength-1,9);
    cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    pos=BinarySearch5(a5,0,aLength-1,28);
    cout<<"("<<pos.first<<","<<pos.second<<")"<<"  ";
    cout<<endl;
}

 

《编程之美》3.11介绍了二分查找，并给出了几个思考问题，上面的代码对几个思考问题给出了解答：

在上述代码中需要注意的几点问题：

1. 为了避免整数的溢出问题，需要写出：middle=low+((high-low)>>1); 最好不要写成middle=(low+high)>>1;

2. 二分代码最需要考虑的就是边界问题，边界也是最容易出错的地方。

3. 上述代码有很多技巧及细节的处理，这也是结合《编程珠玑》第九章给出的编码。

4. 在while循环判断使用low+1!=high而不是使用low<=high，是因为使用后者很难找出最接近value的数。有可能middle最接近value，而每次更新是high=middle+1,low=middle-1，这样就把middle跳过去了。个人见解，欢迎拍砖。

5. 写一个正确高效的二分真得不容易！！！

6. 运行结果如下：