lower_bound

Artykuł
06/09/2015

Znajduje pozycję pierwszego elementu w uporządkowanym zakresie, który ma wartość większą niż lub równą określonej wartości, gdzie kryterium sortowania może być określona przez predykat dwuelementowy.

template<class ForwardIterator, class Type> 
   ForwardIterator lower_bound( 
      ForwardIterator first,  
      ForwardIterator last, 
      const Type& value 
   ); 
template<class ForwardIterator, class Type, class BinaryPredicate> 
   ForwardIterator lower_bound( 
      ForwardIterator first,  
      ForwardIterator last, 
      const Type& value,
      BinaryPredicate comp 
   );

Parametry

first
Iterator postępujący odnosi się do pozycji pierwszego elementu w zakresie wyszukiwania.
last
Iterator postępujący odnosi się do pozycji pierwszej po elemencie końcowym w zakresie wyszukiwania.
value
Wartość, której pierwsza pozycja lub możliwa pierwsza pozycja są wyszukiwane w zakresie uporządkowanym.
comp
Zdefiniowany przez użytkownika obiekt funkcji predykatu, który definiuje sens, w którym jeden element jest mniejszy niż inny.Predykat dwuelementowy przyjmuje dwa argumenty i zwraca wartość true po spełnieniu oraz false, jeśli nie jest spełniony.

Wartość zwracana

Iterator postępujący jest na pozycji pierwszego elementu w uporządkowanym zakresie, z wartością większą niż lub równą określonej wartości, gdzie odpowiednik jest określony przez predykat dwuelementowy.

Uwagi

Wspomniany w odwołaniu sortowany zakres zasobów musi być prawidłowy; wszystkie iteratory muszą być dereferencjalne, a ostatnia pozycja w sekwencji musi być osiągalna z pierwszej dzięki inkrementacji.

Uporządkowany zakres jest warunkiem wstępnym korzystania z lower_bound, gdzie sortowanie jest takie samo, jak określone przez predykat dwuelementowy.

Zakres nie jest modyfikowany przez algorytm lower_bound.

Typy wartości do iteratorów do przodu muszą być mniej-niż porównywalne do zamówienia, tak, że biorąc pod uwagę dwa elementy, można ustalić albo że są one równoważne (w tym sensie, że żaden z nich nie jest mniejszy od drugiego) lub jeden z nich jest mniejszy od drugiego.Skutkuje to ustaleniem kolejności dla elementów nierównoważnych.

Złożoność algorytmu jest logarytmiczna dla iteratorów dostępu liniowego i liniowa w przeciwnym razie z liczbą kroków proporcjonalną do (last – first).

Przykład

// alg_lower_bound.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>      // greater<int>( )
#include <iostream>

// Return whether modulus of elem1 is less than modulus of elem2
bool mod_lesser( int elem1, int elem2 )
{
    if ( elem1 < 0 )
        elem1 = - elem1;
    if ( elem2 < 0 )
        elem2 = - elem2;
    return elem1 < elem2;
}

int main( )
{
    using namespace std;

    vector<int> v1;
    // Constructing vector v1 with default less-than ordering
    for ( auto i = -1 ; i <= 4 ; ++i )
    {
        v1.push_back(  i );
    }

    for ( auto ii =-3 ; ii <= 0 ; ++ii )
    {
        v1.push_back(  ii  );
    }

    cout << "Starting vector v1 = ( " ;
    for (const auto &Iter : v1)
        cout << Iter << " ";
    cout << ")." << endl;

    sort(v1.begin(), v1.end());
    cout << "Original vector v1 with range sorted by the\n "
        << "binary predicate less than is v1 = ( " ;
    for (const auto &Iter : v1)
        cout << Iter << " ";
    cout << ")." << endl;

    // Constructing vector v2 with range sorted by greater
    vector<int> v2(v1);

    sort(v2.begin(), v2.end(), greater<int>());

    cout << "Original vector v2 with range sorted by the\n "
        << "binary predicate greater is v2 = ( " ;
    for (const auto &Iter : v2)
        cout << Iter << " ";
    cout << ")." << endl;

    // Constructing vectors v3 with range sorted by mod_lesser
    vector<int> v3(v1);
    sort(v3.begin(), v3.end(), mod_lesser);

    cout << "Original vector v3 with range sorted by the\n "
        <<  "binary predicate mod_lesser is v3 = ( " ;
    for (const auto &Iter : v3)
        cout << Iter << " ";
    cout << ")." << endl;

    // Demonstrate lower_bound

    vector<int>::iterator Result;

    // lower_bound of 3 in v1 with default binary predicate less<int>()
    Result = lower_bound(v1.begin(), v1.end(), 3);
    cout << "The lower_bound in v1 for the element with a value of 3 is: "
        << *Result << "." << endl;

    // lower_bound of 3 in v2 with the binary predicate greater<int>( )
    Result = lower_bound(v2.begin(), v2.end(), 3, greater<int>());
    cout << "The lower_bound in v2 for the element with a value of 3 is: "
        << *Result << "." << endl;

    // lower_bound of 3 in v3 with the binary predicate  mod_lesser
    Result = lower_bound(v3.begin(), v3.end(), 3,  mod_lesser);
    cout << "The lower_bound in v3 for the element with a value of 3 is: "
        << *Result << "." << endl;
}

Dane wyjściowe

Starting vector v1 = ( -1 0 1 2 3 4 -3 -2 -1 0 ).
Original vector v1 with range sorted by the
 binary predicate less than is v1 = ( -3 -2 -1 -1 0 0 1 2 3 4 ).
Original vector v2 with range sorted by the
 binary predicate greater is v2 = ( 4 3 2 1 0 0 -1 -1 -2 -3 ).
Original vector v3 with range sorted by the
 binary predicate mod_lesser is v3 = ( 0 0 -1 -1 1 -2 2 -3 3 4 ).
The lower_bound in v1 for the element with a value of 3 is: 3.
The lower_bound in v2 for the element with a value of 3 is: 3.
The lower_bound in v3 for the element with a value of 3 is: -3.