【C++ STL算法】二分查找 lower_bound、upper_bound、equal_range、binary_search

MR_Promethus

已于 2024-10-06 22:45:01 修改

阅读量491

点赞数 4

分类专栏： C++ 编程设计文章标签：算法 c++

于 2024-10-06 22:43:48 首次发布

本文链接：https://blog.csdn.net/qq_44431690/article/details/142729763

版权

C++ 编程设计专栏收录该内容

38 篇文章 4 订阅

订阅专栏

文章目录

【 1. 首个不小于 lower_bound 】
【 2. 首个大于 upper_bound 】
【 3. 所有等于 equel_range 】
【 4. 二分查找 binary_search 】

当 指定区域内的数据处于有序状态 时，如果想查找某个目标元素，更推荐使用二分查找的方法（相比顺序查找，二分查找的执行效率更高）。
C++ STL标准库中提供有 lower_bound()、upper_bound()、equal_range() 以及 binary_search() 这 4 个查找函数，它们的底层实现采用的都是 二分查找 的方式。
头文件 <algorithm>

【 1. 首个不小于 lower_bound 】

lower_bound() 函数用于在指定区域内 查找首个不小于目标值 的元素。
基本语法
- first 和 last 都为正向迭代器，[first, last) 是指定查找范围，该 指定区域内必须已排序 。
- val 为指定目标值。
- comp 用于自定义比较规则，此参数可以接收一个包含 2 个形参（第二个形参值始终为 val）且返回值为 bool 类型的函数，可以是普通函数，也可以是函数对象。
- 该函数会 返回一个正向迭代器，当查找成功时，迭代器指向找到的元素；反之，若查找失败，迭代器的指向和 last 迭代器相同。

//在 [first, last) 区域内查找不小于 val 的元素
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,const T& val);

//在 [first, last) 区域内查找第一个不符合 comp 规则的元素
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,const T& val, Compare comp);

实例

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

//以普通函数的方式定义查找规则
bool mycomp(int i, int j) { return i > j; }

//以函数对象的形式定义查找规则
class mycomp2 {
public:
    bool operator()(const int& i, const int& j) {
        return i < j;
    }
};

int main() {
    //从 a 数组中找到第一个不小于 3 的元素
    int a[5] = { 1,2,3,4,5 };
    int* p = lower_bound(a, a + 5, 3);
    cout << "*p = " << *p << endl;

    //根据 mycomp2 规则，从 myvector 容器中找到第一个违背 mycomp2 规则的元素
    vector<int> myvector{ 1,2,3,4,5 };
    vector<int>::iterator iter = lower_bound(myvector.begin(), myvector.end(), 3, mycomp2());
    cout << "*iter = " << *iter;
    return 0;
}

在这里插入图片描述

lower_bound() 函数底层实现的参考代码

template <class ForwardIterator, class T>
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val)
{
    ForwardIterator it;
    iterator_traits<ForwardIterator>::difference_type count, step;
    count = distance(first,last);
    while (count>0)
    {
        it = first; step=count/2; advance (it,step);
        if (*it<val) {  //或者 if (comp(*it,val))，对应第 2 种语法格式
            first=++it;
            count-=step+1;
        }
        else count=step;
    }
    return first;
}

【 2. 首个大于 upper_bound 】

upper_bound() 函数 用于在指定范围内 查找首个大于目标值 的元素。
基本语法
- first 和 last 都为正向迭代器，[first, last) 是查找范围，该 指定区域内必须已排序 。
- val 为指定目标值。
- comp 作用自定义查找规则，此参数可接收一个包含 2 个形参（第一个形参值始终为 val）且返回值为 bool 类型的函数，可以是普通函数，也可以是函数对象。
- 该函数会 返回一个正向迭代器，当查找成功时，迭代器指向找到的元素；反之，若查找失败，迭代器的指向和 last 迭代器相同。

//查找[first, last)区域中第一个大于 val 的元素。
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last,const T& val);

//查找[first, last)区域中第一个不符合 comp 规则的元素
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last,const T& val, Compare comp);

实例

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
//以普通函数的方式定义查找规则
bool mycomp(int i, int j) { return i > j; }

//以函数对象的形式定义查找规则
class mycomp2 {
public:
    bool operator()(const int& i, const int& j) {
        return i <  j;
    }
};

int main() {
    //从 a 数组中找到第一个大于 3 的元素
    int a[5] = { 1,2,3,4,5 };
    int* p = upper_bound(a, a + 5, 3);
    cout << "*p = " << *p << endl;

    //根据 mycomp2 规则，从 myvector 容器中找到第一个违背 mycomp2 规则的元素
    vector<int> myvector{ 1,2,3,4,5 };
    vector<int>::iterator iter = upper_bound(myvector.begin(), myvector.end(), 3, mycomp2());
    cout << "*iter = " << *iter;
    return 0;
}

在这里插入图片描述

upper_bound() 函数底层实现的参考代码

template <class ForwardIterator, class T>
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T& val)
{
    ForwardIterator it;
    iterator_traits<ForwardIterator>::difference_type count, step;
    count = std::distance(first,last);
    while (count>0)
    {
        it = first; step=count/2; std::advance (it,step);
        if (!(val<*it))  // 或者 if (!comp(val,*it)), 对应第二种语法格式
            { first=++it; count-=step+1;  }
        else count=step;
    }
    return first;
}

【 3. 所有等于 equel_range 】

equel_range() 函数用于在指定范围内查找 所有等于目标值的元素 。
基本语法
- first 和 last 都为正向迭代器，[first, last) 是查找范围，该 指定区域内必须已排序 。
- val 为指定目标值。
- comp 作用自定义查找规则，此参数可接收一个包含 2 个形参（第一个形参值始终为 val）且返回值为 bool 类型的函数，可以是普通函数，也可以是函数对象。
- 该函数会 返回一个 pair 类型值 ，其包含 2 个正向迭代器。
  - 查找成功时：第 1 个迭代器指向的是 [first, last) 区域中 第一个等于 val 的元素；第 2 个迭代器指向的是 [first, last) 区域中 第一个大于 val 的元素 。
  - 查找失败时：这 2 个迭代器要么 都指向大于 val 的第一个元素（如果有），要么 都和 last 迭代器指向相同 。

类型	基本语法1	基本语法2
条件	指定范围内的数据支持用 < 小于运算符直接做比较	指定范围内的数据为自定义的类型（用结构体或类），就需要自定义比较规则
语法	//找到 [first, last) 范围中所有等于 val 的元素 pair<ForwardIterator,ForwardIterator> equal_range (ForwardIterator first, ForwardIterator last, const T& val);	//找到 [first, last) 范围内所有等于 val 的元素 pair<ForwardIterator,ForwardIterator> equal_range (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);

实例

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

//以普通函数的方式定义查找规则
bool mycomp(int i, int j) { return i > j; }

//以函数对象的形式定义查找规则
class mycomp2 {
public:
    bool operator()(const int& i, const int& j) {
        return i > j;
    }
};

int main() {
    //从 a 数组中找到所有的元素 4
    int a[9] = { 1,2,3,4,4,4,5,6,7 };
    pair<int*, int*> range = equal_range(a, a + 9, 4);
    cout << "a[9]：";
    for (int* p = range.first; p < range.second; ++p) {
        cout << *p << " ";
    }
    //在 myvector 容器中找到所有的元素 3
    vector<int>myvector{ 7,8,5,4,3,3,3,3,2,1 };
    pair<vector<int>::iterator, vector<int>::iterator> range2;
    range2 = equal_range(myvector.begin(), myvector.end(), 3, mycomp2());
    cout << "\nmyvector：";
    for (auto it = range2.first; it != range2.second; ++it) {
        cout << *it << " ";
    }
    return 0;
}

在这里插入图片描述

equel_range() 函数底层实现的参考代码

//对应第一种语法格式
template <class ForwardIterator, class T>
pair<ForwardIterator,ForwardIterator> equal_range (ForwardIterator first, ForwardIterator last, const T& val)
{
    ForwardIterator it = std::lower_bound (first,last,val);
    return std::make_pair ( it, std::upper_bound(it,last,val) );
}
//对应第二种语法格式
template<class ForwardIterator, class T, class Compare>
std::pair<ForwardIt,ForwardIt> equal_range(ForwardIterator first, ForwardIterator last, const T& val, Compare comp)
{
    ForwardIterator it = std::lower_bound (first,last,val,comp);
    return std::make_pair ( it, std::upper_bound(it,last,val,comp) );
}

【 4. 二分查找 binary_search 】

binary_search() 函数用于查找指定区域内 是否包含某个目标元素 。
基本语法
- first 和 last 都为正向迭代器，[first, last) 是查找范围，该 指定区域内必须已排序 。
- val 为指定目标值。
- comp 作用自定义查找规则，此参数可接收一个包含 2 个形参（第一个形参值始终为 val）且返回值为 bool 类型的函数，可以是普通函数，也可以是函数对象。
- 该函数会 返回一个 bool 类型值 ：
  - 如果 binary_search() 函数在 [first, last) 区域内成功找到和 val 相等的元素，则返回 true ；
  - 反之则返回 false。

类型	基本语法1	基本语法2
条件	查找 [first, last) 区域内是否包含 val	根据 comp 指定的规则，查找 [first, last) 区域内是否包含 val
语法	bool binary_search (ForwardIterator first, ForwardIterator last,const T& val);	bool binary_search (ForwardIterator first, ForwardIterator last,const T& val, Compare comp);

实例

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

//以普通函数的方式定义查找规则
bool mycomp(int i, int j) { return i > j; }

//以函数对象的形式定义查找规则
class mycomp2 {
public:
    bool operator()(const int& i, const int& j) {
        return i > j;
    }
};
int main() {
    //从 a 数组中查找元素 4
    int a[7] = { 1,2,3,4,5,6,7 };
    bool haselem = binary_search(a, a + 9, 4);
    cout << "haselem：" << haselem << endl;

    //从 myvector 容器查找元素 3
    vector<int>myvector{ 4,5,3,2,1 };
    bool haselem2 = binary_search(myvector.begin(), myvector.end(), 3, mycomp2());
    cout << "haselem2：" << haselem2;
    return 0;
}

在这里插入图片描述

binary_search() 函数底层实现的参考代码

//第一种语法格式的实现
template <class ForwardIterator, class T>
bool binary_search (ForwardIterator first, ForwardIterator last, const T& val)
{
    first = std::lower_bound(first,last,val);
    return (first!=last && !(val<*first));
}
//第二种语法格式的底层实现
template<class ForwardIt, class T, class Compare>
bool binary_search(ForwardIt first, ForwardIt last, const T& val, Compare comp)
{
    first = std::lower_bound(first, last, val, comp);
    return (!(first == last) && !(comp(val, *first)));
}