std:: minmax_element

Trouve le plus petit et le plus grand élément dans la plage [ first , last ) .

Paramètres

Valeur de retour

une paire constituée d'un itérateur vers le plus petit élément comme premier élément et d'un itérateur vers le plus grand élément comme second. Retourne std:: make_pair ( first, first ) si la plage est vide. Si plusieurs éléments sont équivalents au plus petit élément, l'itérateur vers le premier de ces éléments est retourné. Si plusieurs éléments sont équivalents au plus grand élément, l'itérateur vers le dernier de ces éléments est retourné.

Complexité

Étant donné \(\scriptsize N\) N comme std:: distance ( first, last ) :

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
• Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levé.

Implémentation possible

template<class ForwardIt>
std::pair<ForwardIt, ForwardIt>
    minmax_element(ForwardIt first, ForwardIt last)
{
    using value_type = typename std::iterator_traits<ForwardIt>::value_type;
    return std::minmax_element(first, last, std::less<value_type>());
}

template<class ForwardIt, class Compare>
std::pair<ForwardIt, ForwardIt>
    minmax_element(ForwardIt first, ForwardIt last, Compare comp)
{
    auto min = first, max = first;
    if (first == last || ++first == last)
        return {min, max};
    if (comp(*first, *min))
        min = first;
    else
        max = first;
    while (++first != last)
    {
        auto i = first;
        if (++first == last)
        {
            if (comp(*i, *min))
                min = i;
            else if (!(comp(*i, *max)))
                max = i;
            break;
        }
        else
        {
            if (comp(*first, *i))
            {
                if (comp(*first, *min))
                    min = first;
                if (!(comp(*i, *max)))
                    max = i;
            }
            else
            {
                if (comp(*i, *min))
                    min = i;
                if (!(comp(*first, *max)))
                    max = first;
            }
        }
    }
    return {min, max};
}

Notes

Cet algorithme diffère de std:: make_pair ( std:: min_element ( ) , std:: max_element ( ) ) , non seulement en efficacité, mais aussi en ce que cet algorithme trouve le dernier plus grand élément tandis que std::max_element trouve le premier plus grand élément.

Exemple

#include <algorithm>
#include <iostream>
int main()
{
    const auto v = {3, 9, 1, 4, 2, 5, 9};
    const auto [min, max] = std::minmax_element(begin(v), end(v));
    std::cout << "min = " << *min << ", max = " << *max << '\n';
}

min = 1, max = 9

Voir aussi