lower_bound的使用

unction template

<algorithm>

std::lower_bound

default (1)	template <class ForwardIterator, class T> ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val);
custom (2)	template <class ForwardIterator, class T, class Compare> ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T& val, Compare comp);

Return iterator to lower bound

Returns an iterator pointing to the first element in the range[first,last) which does not compare less than val.

The elements are compared using operator< for the first version, andcomp for the second. The elements in the range shall already be sorted according to this same criterion (operator< or comp), or at leastpartitioned with respect toval.

The function optimizes the number of comparisons performed by comparing non-consecutive elements of the sorted range, which is specially efficient forrandom-access iterators.

Unlike upper_bound, the value pointed by the iterator returned by this function may also be equivalent toval, and not only greater.

Parameters

first, last

Forward iterators to the initial and final positions of asorted (or properlypartitioned) sequence. The range used is[first,last), which contains all the elements between first andlast, including the element pointed by first but not the element pointed bylast.

val

Value of the lower bound to search for in the range.
For (1), T shall be a type supporting being compared with elements of the range[first,last) as the right-hand side operand of operator<.

comp

Binary function that accepts two arguments (the first of the type pointed byForwardIterator, and the second, always val), and returns a value convertible tobool. The value returned indicates whether the first argument is considered to go before the second.
The function shall not modify any of its arguments.
This can either be a function pointer or a function object.

Return value

An iterator to the lower bound of val in the range.
If all the element in the range compare less than val, the function returnslast.

Complexity

On average, logarithmic in the distance between first and last: Performs approximatelylog2(N)+1 element comparisons (where N is this distance).
On non-random-access iterators, the iteratoradvances produce themselves an additional linear complexity inN on average.

註解：第一個函數不需要自定義比較運算符，第二個需要。

lower_bound返回第一個滿足大於等於指定val值的元素的迭代器，upper_bound返回最後一個滿足大於等於指定val值的元素的迭代器。找不到滿足條件的元素就返回end迭代器。

查找的時間複雜度是log2(N)+1

實例程序：

// lower_bound/upper_bound example
#include <iostream>     // std::cout
#include <algorithm>    // std::lower_bound, std::upper_bound, std::sort
#include <vector>       // std::vector

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};
  std::vector<int> v(myints,myints+8);           // 10 20 30 30 20 10 10 20

  std::sort (v.begin(), v.end());                // 10 10 10 20 20 20 30 30

  std::vector<int>::iterator low,up;
  low=std::lower_bound (v.begin(), v.end(), 20); //          ^
  up= std::upper_bound (v.begin(), v.end(), 20); //                   ^

  std::cout << "lower_bound at position " << (low- v.begin()) << '\n';
  std::cout << "upper_bound at position " << (up - v.begin()) << '\n';

  return 0;
}

運行結果：

lower_bound at position 3
upper_bound at position 6