std::minmax_element

template< class ForwardIt >
std::pair<ForwardIt, ForwardIt>
    minmax_element( ForwardIt first, ForwardIt last );

template< class ExecutionPolicy, class ForwardIt >
std::pair<ForwardIt, ForwardIt>
    minmax_element( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last );

template< class ForwardIt, class Compare >
std::pair<ForwardIt, ForwardIt>
    minmax_element( ForwardIt first, ForwardIt last, Compare comp );

template< class ExecutionPolicy, class ForwardIt, class Compare >
std::pair<ForwardIt, ForwardIt>
    minmax_element( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last, Compare comp );

Findet das kleinste und das größte Element im Bereich [first, last).

Parameter

Rückgabewert

ein Paar bestehend aus einem Iterator auf das kleinste Element als erstes Element und einem Iterator auf das größte Element als zweites. Gibt std::make_pair(first, first) zurück, wenn der Bereich leer ist. Wenn mehrere Elemente äquivalent zum kleinsten Element sind, wird der Iterator auf das erste solche Element zurückgegeben. Wenn mehrere Elemente äquivalent zum größten Element sind, wird der Iterator auf das letzte solche Element zurückgegeben.

Komplexität

Gegeben \(\scriptsize N\)N als std::distance(first, last):

Ausnahmen

Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

• Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Ausnahme auslöst und ExecutionPolicy eine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jedes andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
• Wenn der Algorithmus Speicher nicht zuweisen kann, wird std::bad_alloc ausgelöst.

Mögliche Implementierung

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};
}

Hinweise

Dieser Algorithmus unterscheidet sich von std::make_pair(std::min_element(), std::max_element()), nicht nur in der Effizienz, sondern auch darin, dass dieser Algorithmus das letzte größte Element findet, während std::max_element das erste größte Element findet.

Beispiel

#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

Siehe auch