std:: minmax_element

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

Parameter

Rückgabewert

Ein Paar, bestehend aus einem Iterator zum kleinsten Element als erstes Element und einem Iterator zum größten Element als zweites Element. Gibt std:: make_pair ( first, first ) zurück, wenn der Bereich leer ist. Wenn mehrere Elemente dem kleinsten Element entsprechen, wird der Iterator zum ersten solchen Element zurückgegeben. Wenn mehrere Elemente dem größten Element entsprechen, wird der Iterator zum letzten solchen 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 Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jeden anderen ExecutionPolicy ist das Verhalten implementierungsdefiniert.
• Wenn der Algorithmus keinen Speicher allokieren kann, wird std::bad_alloc geworfen.

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