std::sort

template< class RandomIt >
void sort( RandomIt first, RandomIt last );

template< class ExecutionPolicy, class RandomIt >
void sort( ExecutionPolicy&& policy,
           RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );

template< class ExecutionPolicy, class RandomIt, class Compare >
void sort( ExecutionPolicy&& policy,
           RandomIt first, RandomIt last, Compare comp );

Ordena los elementos en el rango [first, last) en orden no descendente. No se garantiza que se conserve el orden de los elementos iguales.

Si se cumple alguna de las siguientes condiciones, el comportamiento no está definido:

Parámetros

Complejidad

Dado \(\scriptsize N\) N como last - first :

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy reportan 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 uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

Consulte también las implementaciones en libstdc++ y libc++ .

Notas

Antes de LWG713 , el requisito de complejidad permitía que sort() se implementara utilizando únicamente Quicksort , lo cual podría requerir \(\scriptsize O(N^2)\) O(N 2
) comparaciones en el peor caso.

Introsort puede manejar todos los casos con \(\scriptsize O(N \cdot \log(N))\) O(N·log(N)) comparaciones (sin incurrir en sobrecarga adicional en el caso promedio), y por lo tanto se utiliza generalmente para implementar sort() .

libc++ no ha implementado el requisito de complejidad temporal corregido hasta LLVM 14 .

Ejemplo

#include <algorithm>
#include <array>
#include <functional>
#include <iostream>
#include <string_view>
int main()
{
    std::array<int, 10> s{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    auto print = [&s](std::string_view const rem)
    {
        for (auto a : s)
            std::cout << a << ' ';
        std::cout << ": " << rem << '\n';
    };
    std::sort(s.begin(), s.end());
    print("ordenado con el operador< predeterminado");
    std::sort(s.begin(), s.end(), std::greater<int>());
    print("ordenado con el objeto función de comparación de la biblioteca estándar");
    struct
    {
        bool operator()(int a, int b) const { return a < b; }
    }
    customLess;
    std::sort(s.begin(), s.end(), customLess);
    print("ordenado con un objeto función personalizado");
    std::sort(s.begin(), s.end(), [](int a, int b)
                                  {
                                      return a > b;
                                  });
    print("ordenado con una expresión lambda");
}

0 1 2 3 4 5 6 7 8 9 : ordenado con el operador< predeterminado
9 8 7 6 5 4 3 2 1 0 : ordenado con el objeto función de comparación de la biblioteca estándar
0 1 2 3 4 5 6 7 8 9 : ordenado con un objeto función personalizado
9 8 7 6 5 4 3 2 1 0 : ordenado con una expresión lambda

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también