Comment utiliser comp dans lower_bound

Comment utiliser comp dans lower_bound

définition:

Il existe deux définitions, une avec fonction comp et une sans fonction comp.

template< class ForwardIt, class T >
constexpr ForwardIt lower_bound( ForwardIt first, ForwardIt last,
                                 const T& value );
template< class ForwardIt, class T, class Compare >
constexpr ForwardIt lower_bound( ForwardIt first, ForwardIt last,
                                 const T& value, Compare comp );

paramètre:

first,last - Itérateurs jusqu'au début et à la fin de la plage ordonnée à rechercher, la plage de recherche est [first, last).

valeur - la valeur à comparer

comp - fonction de comparaison, utilisée pour personnaliser les règles de comparaison. La valeur de retour de cette fonction est l'une des valeurs true et false.

 bool pred(const Type1 &a, const Type2 &b);
 bool pred(const Type1 a, const Type2 b);

Parmi eux, Type1 doit être le type d'objet pointé par le pointeur ForwardIt.

valeur de retour :

Renvoie un itérateur. Retourne un itérateur sur le element < valuepremier comp(element, value)élément qui ne satisfait pas ou retourne false si aucun elementtel last. En termes simples, il s'agit de retourner le pointeur du premier element>valueet le premier comp(element, value)élément qui ne respecte pas les règles. C'est-à-dire que le contenu de l'espace d'adressage à comparer est passé à comp(element, value)la fonction, et un tableau est obtenu [true,true,....true,false,...false], et l'adresse du premier est renvoyée false.

code source:

template<class ForwardIt, class T, class Compare>
ForwardIt lower_bound(ForwardIt first, ForwardIt last, const T& value, Compare comp)
{
    
    
    ForwardIt it;
    typename std::iterator_traits<ForwardIt>::difference_type count, step;
    count = std::distance(first, last);
 
    while (count > 0)
    {
    
    
        it = first;
        step = count / 2;
        std::advance(it, step);
 
        if (comp(*it, value))
        {
    
    
            first = ++it;
            count -= step + 1;
        }
        else
            count = step;
    }
 
    return first;
}

exemple concret

Afin de mieux comprendre comp(element, value)la fonction, j'utilise un tableau non ordonné pour comparaison ci-dessous, ce qui est fortement déconseillé dans les applications pratiques !

Selon le code source : distance(first, last) = 6, le premier pas de temps = 3, il comparera alls[3]avec 4 et retournera true, donc l'espace de recherche devient [4,6] à ce moment. La deuxième fois alls[5]comparera avec 4 et reviendra, trueà ce moment l'espace de recherche devient [6,6]. La troisième fois comparera alls[6]avec 4, return true, à ce moment count<0, sortira de la boucle, return subscript 7, c'est-à-dire alls.end().

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    
    
    vector<int> alls{
    
    5, 7, 1, 4, 2, 3, 1};
    auto it = lower_bound(alls.begin(), alls.end(), 4,
                          [](const int &element, const int &value)
                          {
    
    
                              return element <= value;
                          });
    if(it == alls.end()) cout<<"Not find!"<<endl;
    else cout << "Position is" << it - alls.begin() << endl;
    return 0;
}
运行结果：
Not find!

un autre exemple:

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    
    
    vector<int> alls{
    
    6, 5, 4, 3, 2, 1, 0};
    auto it = lower_bound(alls.begin(), alls.end(), 4,
                          [](const int &element, const int &value)
                          {
    
    
                              return element >= value;
                          });
    if(it == alls.end()) cout<<"Not find!"<<endl;
    cout << "Position is " << it - alls.begin() << endl;
    return 0;
}
运行结果：
Position is 3

Résumé : Pour les séquences ascendantes, la valeur de retour ne peut être écrite element <= valueque sous la forme ou element < value, et vice versa pour les séquences descendantes.

Enfin, attachez le code de référence dans cppreference :

#include <algorithm>
#include <iostream>
#include <vector>
 
struct PriceInfo {
    
     double price; };
 
int main()
{
    
    
    const std::vector<int> data {
    
    1, 2, 4, 5, 5, 6};
 
    for (int i = 0; i < 8; ++i)
    {
    
    
        // Search for first element x such that i ≤ x
        auto lower = std::lower_bound(data.begin(), data.end(), i);
 
        std::cout << i << " ≤ ";
        lower != data.end()
            ? std::cout << *lower << " at index " << std::distance(data.begin(), lower)
            : std::cout << "not found";
        std::cout << '\n';
    }
 
    std::vector<PriceInfo> prices {
    
    {
    
    100.0}, {
    
    101.5}, {
    
    102.5}, {
    
    102.5}, {
    
    107.3}};
 
    for (double to_find : {
    
    102.5, 110.2})
    {
    
    
        auto prc_info = std::lower_bound(prices.begin(), prices.end(), to_find,
            [](const PriceInfo& info, double value)
            {
    
    
                return info.price < value;
            });
 
        prc_info != prices.end()
            ? std::cout << prc_info->price << " at index " << prc_info - prices.begin()
            : std::cout << to_find << " not found";
        std::cout << '\n';
    }
}

résultat de l'opération :

0 ≤ 1 at index 0
1 ≤ 1 at index 0
2 ≤ 2 at index 1
3 ≤ 4 at index 2
4 ≤ 4 at index 2
5 ≤ 5 at index 3
6 ≤ 6 at index 5
7 ≤ not found
102.5 at index 2
110.2 not found