std::upper_bound与std::lower_bound

std::lower_bound

用法1：在升序中 lower_bound() 函数用于在指定区域内查找第一个元素大于等于val的值

形式一：

  template<typename _ForwardIterator, typename _Tp>
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
		const _Tp& __val)

形式二：

ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,
                             const T& val, Compare comp);
comp 的第2个参数始终是val的类型

#include <iostream>     // std::cout
#include <algorithm>    // std::upper_bound
#include <vector>       // std::vector
using namespace std;
struct Point {
  Point(int in):s(in){}
  int s;
};

bool LowerBoundComparator(const Point& p, int val) {
 return p.s < val;
}

int main() {
    Point p1(1);
    Point p2(1);
    Point p3(3);
    Point p4(3);
    Point p5(5);
    vector<Point> vector{ p1,p2,p3,p4,p5};// 1 1 3 3 5
    // vector 容器中找到第一个违背 LowerBoundComparator 规则的元素,即大于等于val的值
    auto iter = lower_bound(vector.begin(), vector.end(),3,LowerBoundComparator);
    cout << "*iter = " <<iter->s<<", index="<< iter - vector.begin()<<endl;
    return 0;
}

输出结果 *iter = 3, index=2

用法2： 在降序中lower_bound() 函数用于在指定区域内查找第一个元素小于等于val的值,这个时候需要改变系统默认的比较规则，无论是形式1还是形式2

注意看LowerBoundComparator返回规则与用法1 的区别

#include <iostream>     // std::cout
#include <algorithm>    // std::upper_bound
#include <vector>       // std::vector
using namespace std;
struct Point {
  Point(int in):s(in){}
  int s;
};

bool LowerBoundComparator(const Point& p, int val) {
  //return p.s < val;
  return val < p.s;
}

int main() {
    Point p1(10);
    Point p2(9);
    Point p3(8);
    Point p4(8);
    Point p5(5);
    vector<Point> vector{ p1,p2,p3,p4,p5};// 10 9 8 8 5
    // vector 容器中找到第一个违背 LowerBoundComparator 规则的元素,即小于等于val的值
    auto iter = lower_bound(vector.begin(), vector.end(),8,LowerBoundComparator);
    cout << "*iter = " <<iter->s<<", index="<< iter - vector.begin()<<endl;
    return 0;
}

 std::upper_bound

用法1：在升序中 upper_bound() 函数用于在指定区域内查找第一个元素大于val的值

用自定义cmp函数，第一个参数为val的类型

#include <iostream>     // std::cout
#include <algorithm>    // std::upper_bound
#include <vector>       // std::vector
using namespace std;
struct Point {
  Point(int in):s(in){}
  int s;
};

bool UpperBoundComparator(int val, const Point& p) {
  //return p.s < val;
  return val < p.s;
}

int main() {
    Point p1(1);
    Point p2(3);
    Point p3(3);
    Point p4(5);
    Point p5(8);
    vector<Point> vector{ p1,p2,p3,p4,p5};// 1 3 3 5 8
    // vector 容器中找到第一个违背 UpperBoundComparator 规则的元素,即大于val的值
    auto iter = upper_bound(vector.begin(), vector.end(),3,UpperBoundComparator);
    cout << "*iter = " <<iter->s<<", index="<< iter - vector.begin()<<endl;

    return 0;
}

 输出结果：  *iter = 5, index=3

用法2： 在降序中，upper_bound() 函数用于在指定区域内查找第一个元素小于val的值

#include <iostream>     // std::cout
#include <algorithm>    // std::upper_bound
#include <vector>       // std::vector
using namespace std;
struct Point {
  Point(int in):s(in){}
  int s;
};

bool UpperBoundComparator(int val, const Point& p) {
  return p.s < val;
 // return val < p.s;
}

int main() {
    Point p1(8);
    Point p2(5);
    Point p3(5);
    Point p4(3);
    Point p5(1);
    vector<Point> vector{ p1,p2,p3,p4,p5};// 8 5 5 3 1
    // vector 容器中找到第一个违背 UpperBoundComparator 规则的元素,即小于val的值
    auto iter = upper_bound(vector.begin(), vector.end(),5,UpperBoundComparator);
    cout << "*iter = " <<iter->s<<", index="<< iter - vector.begin()<<endl;

    return 0;
}

输出结果：  *iter = 3, index=3