Namespaces
Variants

std::forward_list<T,Allocator>:: sort

From cppreference.net

C++
Containers library
std::forward_list
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
void sort ( ) ;
(1) (desde C++11)
(constexpr desde C++26)
template < class Compare >
void sort ( Compare comp ) ;
(2) (desde C++11)
(constexpr desde C++26)

Ordena los elementos y preserva el orden de los elementos equivalentes. Si se lanza una excepción, el orden de los elementos en * this no está especificado.

1) Los elementos se comparan utilizando operator < .
2) Los elementos se comparan utilizando comp .

Ninguna referencia o iterador se invalida.

Contenidos

Parámetros

comp - objeto función de comparación (es decir, un objeto que satisface los requisitos de Compare ) que devuelve ​ true si el primer argumento es menor que (es decir, está ordenado antes de) el segundo.

La firma de la función de comparación debe ser equivalente a la siguiente:

bool cmp ( const Type1 & a, const Type2 & b ) ;

Aunque la firma no necesita tener const & , la función no debe modificar los objetos pasados a ella y debe poder aceptar todos los valores de tipo (posiblemente const) Type1 y Type2 independientemente de la categoría de valor (por lo tanto, Type1& no está permitido , ni tampoco Type1 a menos que para Type1 un movimiento sea equivalente a una copia (desde C++11) ).
Los tipos Type1 y Type2 deben ser tales que un objeto de tipo forward_list < T,Allocator > :: const_iterator pueda ser desreferenciado y luego convertido implícitamente a ambos. ​

Requisitos de tipo
-
Compare debe cumplir con los requisitos de Compare .

Complejidad

Dado N como std:: distance ( begin ( ) , end ( ) ) :

1) Aproximadamente N·log(N) comparaciones usando operator < .
2) Aproximadamente N·log(N) aplicaciones de la función de comparación comp .

Notas

std::sort requiere iteradores de acceso aleatorio y por lo tanto no puede utilizarse con forward_list . Esta función también se diferencia de std::sort en que no requiere que el tipo de elemento de la forward_list sea intercambiable, preserva los valores de todos los iteradores y realiza una ordenación estable.

Ejemplo

Ejecutar este código 
#include <functional>
#include <iostream>
#include <forward_list>
std::ostream& operator<<(std::ostream& ostr, const std::forward_list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}
int main()
{
    std::forward_list<int> list{8, 7, 5, 9, 0, 1, 3, 2, 6, 4};
    std::cout << "inicialmente: " << list << '\n';
    list.sort();
    std::cout << "ascendente: " << list << '\n';
    list.sort(std::greater<int>());
    std::cout << "descendente:" << list << '\n';
}

Salida: 

inicialmente:  8 7 5 9 0 1 3 2 6 4
ascendente:  0 1 2 3 4 5 6 7 8 9
descendente: 9 8 7 6 5 4 3 2 1 0

Véase también

invierte el orden de los elementos
(función miembro pública)