C++ 手写实现类似lower_bound和upper_bound的二分功能

目录

lower_bound和upper_bound介绍

lower_bound函数的作用是查找范围内第一个大于等于目标元素的元素迭代器/指针

数组的简单使用：

int num[5]={1,3,5,7,9};
int *pos=lower_bound(num,num+5,key);

int num[5]={1,3,5,7,9}
int pos=lower_bound(num,num+5,key)-num;

vector容器的简单使用:

vector<int> ve{1,3,5,7,9}
vector<int>::iterator pos=lower_bound(ve.begin(),ve.end(),key);

vector<int> ve{1,3,5,7,9}
auto pos=lower_bound(ve.begin(),ve.end(),key)-ve.begin();

upper_bound的作用是查找范围内第一个大于目标元素的元素迭代器/指针
使用方法和lower_bound相同

手动实现类似的二分效果

lower_bound函数是查找范围内第一个大于等于
upper_bound函数是查找范围内第一个大于
并且如果范围内没有符合条件的值，就返回范围内最后一个元素的下一个迭代器/指针

接下来将写两个简单的二分函数，实现二分查找目标范围内第一个大于等于/大于的值，如果找不到范围内最后一个元素的下一个元素的位置.

lower_bound

#include<bits/stdc++.h>
using namespace std;

int lower_bound(int a[],int left,int right,int key)
{
    while(left<=right)
    {
        int mid=(left+right)>>1;
        
        if(a[mid]>=key)
        {
            right=mid-1;
        }
        else
        left=mid+1; 
    }
    
    return left;
 } 
int main()
{
    int a[5]={1,3,5,7,9};
    
    cout<< lower_bound(a,0,4,6) <<endl;
    cout<< lower_bound(a,0,4,100)<<endl;
}

upper_bound

#include<bits/stdc++.h>
using namespace std;

int upper_bound(int a[],int left,int right,int key)
{
    while(left<=right)
    {
        int mid=(left+right)>>1;
        
        if(a[mid]>key)
        {
            right=mid-1;
        }
        else
        left=mid+1; 
    }
    
    return left;
 } 
int main()
{
    int a[5]={1,3,5,7,9};
    
    cout<< upper_bound(a,0,4,6) <<endl;
    cout<< upper_bound(a,0,4,100)<<endl;
}

另一种常见的二分形式

这样写也能实现二分的功能，但是没办法在找不到的情况下返回正确的值.

#include<bits/stdc++.h>
using namespace std;

int lower_bound(int a[],int left,int right,int key)
{
    while(left<right)
    {
        int mid=(left+right)>>1;
        
        cout<<left<<" "<<right<<" "<<mid<<endl;
        
        if(a[mid]>=key)
        {
            right=mid;
        }
        else
        left=mid+1; 
    }
    
    return left;
 } 
int main()
{
    int a[5]={1,3,5,7,9};
    
    cout<< lower_bound(a,0,4,7) <<endl;
}

对lower_bound函数使用lamda函数

lower_bound函数是实际是有四个参数的

最后一个参数是比较规则，我们可以在第四个参数的位置，放上函数指针自定义排序规则.

也可以放入lamda表达式
仔细看，lower_bound函数中的_Val也就是上文说的Key值，它会在运行过程中将自己的值传递给比较函数中的第二个参数.

代码：

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

vector<int> ve{ -1,3,-5,-6,7 };
int main()
{
    std::sort(ve.begin(), ve.end());

    int pos = lower_bound(ve.begin(), ve.end(), 3, [](int a, int b) {

        cout << a << " " << b << endl;

        return a < b;
        }) - ve.begin();

    cout << pos << endl;
}

我们可以打印a和b来观察二分过程中lamda表达式中参数的变化.发现参数b的值始终=_Val的值是不变的.

我们可以自定义二分的规则，但是前提是，二分的数组必须是有序的（升序或者降序）都行,并且比较的规则也需要是有单调性的.

我们也可以利用lamda函数对一个降序的数组，求数组中第一个小于等于目标元素的元素位置

代码：

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> ve{ -1,3,-5,-6,7 };
int main()
{
    std::sort(ve.begin(), ve.end(),[](int a,int b)
    {
        return a>b;
    });
    // 7 3 -1 -5 -6
    
    int pos=lower_bound(ve.begin(),ve.end(),-7,[](int a,int b){
        
        return a>b;
    })-ve.begin();
    
    cout<<pos<<endl;
}