递减/非递增向量的下限和上限

问题描述

我理解了为递增/递增数组找到的下限和上限的概念。 即

1. 下界：迭代器指向范围 [first,last) >= Value 中的第一个元素
2. 上限： 指向范围 [first,last) > Value
中第一个元素的迭代器

以下是我遇到问题的递减/非递增向量代码：

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main()
{
    vector<int> vec = {45,40,35,12,6,3};

    auto itr3 = lower_bound(vec.begin(),vec.end(),40);
    auto itr4 = upper_bound(vec.begin(),40);

    if(itr3 == vec.end() && itr4 == vec.end())
        cout<<"Lower & Upper Bound not Found\n";
    else
    {
        cout <<"lower Bound of 40 :"<<*itr3<<endl;
        cout <<"Upper Bound of 40 :"<<*itr4<<endl;
    }

    return 0;
}

输出是：

Lower & Upper Bound not Found.

但如上所述，输出应该类似于：

lower Bound of 40 :40
Upper Bound of 40 :45

请帮助我理解他在递减/非递增向量的情况下的下界和上限行为。

解决方法

std::lower_bound 和 std::upper_bound 的目标必须是递增（非递减）顺序。

您可以通过在函数的第 4 个参数中指定一个比较器来更改“增加”的定义。

您可以使用 std::greater 处理降序向量。

#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>

using namespace std;

int main()
{
    vector<int> vec = {45,40,35,12,6,3};

    auto itr3 = lower_bound(vec.begin(),vec.end(),std::greater<int>());
    auto itr4 = upper_bound(vec.begin(),std::greater<int>());

    if(itr3 == vec.end() && itr4 == vec.end())
        cout<<"Lower & Upper Bound not Found\n";
    else
    {
        cout <<"lower Bound of 40 :"<<*itr3<<endl;
        cout <<"Upper Bound of 40 :"<<*itr4<<endl;
    }

    return 0;
}

,

您需要将算法 std::lower_bound 和 std::upper_bound 的另一个重载声明与比较函数一起使用，例如标准函数对象 std::greater。

这是一个演示程序。

#include <iostream>
#include <functional>
#include <vector>
#include <iterator>
#include <algorithm>


int main() 
{
    std::vector<int> vec = { 45,3 };
    
    auto lower_bound = std::lower_bound( std::begin( vec ),std::end( vec ),std::greater<int>() );

    auto upper_bound = std::upper_bound( std::begin( vec ),std::greater<int>() );
                                         
    std::cout << *lower_bound << " <-> " << *upper_bound << '\n';
    
    return 0;
}

程序输出为

40 <-> 35

为了简单起见，我没有检查程序中返回的迭代器是否等于 std::end( vec ) 返回的迭代器。

您可以使用自己的 lambda 表达式代替标准函数对象 std::greater。例如

auto descending = []( const auto &x,const auto &y )
                  {
                    return y < x;
                  };
                  
auto lower_bound = std::lower_bound( std::begin( vec ),descending );

auto upper_bound = std::upper_bound( std::begin( vec ),descending );

,

您可以使用反向迭代器来获得 40/45 结果：

#include <algorithm>
#include <cstdio>
#include <vector>

int main() {
  std::vector<int> const vec = { 45,3 };

  auto const it_lb = std::lower_bound(vec.rbegin(),vec.rend(),40);
  auto const it_ub = std::upper_bound(vec.rbegin(),40);

  std::printf("Lower: %d\nUpper: %d\n",*it_lb,*it_ub);
}