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

Encuentra el elemento más pequeño y el más grande en el rango [first, last).

Parámetros

Valor de retorno

un par que consiste en un iterador al elemento más pequeño como primer elemento y un iterador al elemento más grande como segundo elemento. Devuelve std::make_pair(first, first) si el rango está vacío. Si varios elementos son equivalentes al elemento más pequeño, se devuelve el iterador al primero de dichos elementos. Si varios elementos son equivalentes al elemento más grande, se devuelve el iterador al último de dichos elementos.

Complejidad

Dado \(\scriptsize N\)N como std::distance(first, last):

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy informan errores de la siguiente manera:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es una de las políticas estándar, se llama a std::terminate. Para cualquier otro ExecutionPolicy, el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Posible implementación

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

Notas

Este algoritmo es diferente de std::make_pair(std::min_element(), std::max_element()), no solo en eficiencia, sino también en que este algoritmo encuentra el elemento más grande último mientras que std::max_element encuentra el elemento más grande primero.

Ejemplo

#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

Véase también