std::ranges::stable_sort

template< std::random_access_iterator I, std::sentinel_for<I> S,
          class Comp = ranges::less, class Proj = std::identity >
requires std::sortable<I, Comp, Proj>
    I stable_sort( I first, S last, Comp comp = {}, Proj proj = {} );

template< ranges::random_access_range R, class Comp = ranges::less,
          class Proj = std::identity >
requires std::sortable<ranges::iterator_t<R>, Comp, Proj>
ranges::borrowed_iterator_t<R>
    stable_sort( R&& r, Comp comp = {}, Proj proj = {} );

Ordena los elementos en el rango [first, last) en orden no descendente. El orden de los elementos equivalentes es estable, es decir, se garantiza que se conserva.

Una secuencia está ordenada con respecto a un comparador comp si para cualquier iterador it que apunte a la secuencia y cualquier entero no negativo n tal que it + n sea un iterador válido que apunte a un elemento de la secuencia, std::invoke(comp, std::invoke(proj, *(it + n)), std::invoke(proj, *it) se evalúa como false.

Las entidades similares a funciones descritas en esta página son objetos de función de algoritmo (conocidos informalmente como niebloids), es decir:

• No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
• Ninguno de ellos es visible para la búsqueda dependiente de argumentos.
• Cuando cualquiera de ellos es encontrado por búsqueda normal no calificada como el nombre a la izquierda del operador de llamada de función, la búsqueda dependiente de argumentos se inhibe.

Parámetros

Valor de retorno

Un iterador igual a last .

Complejidad

\(\scriptsize N\cdot\log{(N)}\) N·log(N) comparaciones, si hay memoria adicional disponible; donde \(\scriptsize N\) N es ranges:: distance ( first, last ) . \(\scriptsize N\cdot\log^2{(N)}\) N·log²(N) comparaciones en caso contrario. El doble de proyecciones que el número de comparaciones en ambos casos.

Notas

Implementación posible

Esta implementación solo muestra el algoritmo más lento utilizado cuando no hay memoria adicional disponible. Consulte también la implementación en MSVC STL y libstdc++ .

struct stable_sort_fn
{
    template<std::random_access_iterator I, std::sentinel_for<I> S,
             class Comp = ranges::less, class Proj = std::identity>
    requires std::sortable<I, Comp, Proj>
    constexpr //< desde C++26
    I operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        auto count = ranges::distance(first, last);
        auto mid = first + count / 2;
        auto last_it = first + count;
        if (count <= 1)
            return last_it;
        (*this)(first, mid, std::ref(comp), std::ref(proj));
        (*this)(mid, last_it, std::ref(comp), std::ref(proj));
        ranges::inplace_merge(first, mid, last_it);
        return last_it;
    }
    template<ranges::random_access_range R, class Comp = ranges::less,
             class Proj = std::identity>
    requires std::sortable<ranges::iterator_t<R>, Comp, Proj>
    constexpr //< desde C++26
    ranges::borrowed_iterator_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(comp), std::move(proj));
    }
};
inline constexpr stable_sort_fn stable_sort{};

Ejemplo

#include <algorithm>
#include <array>
#include <functional>
#include <iomanip>
#include <iostream>
void print(const auto& seq)
{
    for (const auto& elem : seq)
        std::cout << elem << ' ';
    std::cout << '\n';
}
struct Particle
{
    std::string name; double mass; // MeV
    friend std::ostream& operator<<(std::ostream& os, const Particle& p)
    {
        return os << '\n' << std::left << std::setw(8) << p.name << " : " << p.mass;
    }
};
int main()
{
    std::array s{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    // ordenar usando el operador < por defecto
    std::ranges::stable_sort(s);
    print(s);
    // ordenar usando un objeto función de la biblioteca estándar
    std::ranges::stable_sort(s, std::ranges::greater());
    print(s);
    // ordenar usando un objeto función personalizado
    struct
    {
        bool operator()(int a, int b) const { return a < b; }
    } customLess;
    std::ranges::stable_sort(s.begin(), s.end(), customLess);
    print(s);
    // ordenar usando una expresión lambda
    std::ranges::stable_sort(s, [](int a, int b) { return a > b; });
    print(s);
    // ordenar con proyección
    Particle particles[]
    {
        {"Electron", 0.511}, {"Muon", 105.66}, {"Tau", 1776.86},
        {"Positron", 0.511}, {"Proton", 938.27}, {"Neutron", 939.57}
    };
    print(particles);
    std::ranges::stable_sort(particles, {}, &Particle::name); //< ordena por nombre
    print(particles);
    std::ranges::stable_sort(particles, {}, &Particle::mass); //< ordena por masa
    print(particles);
}

0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0
Electron : 0.511
Muon     : 105.66
Tau      : 1776.86
Positron : 0.511
Proton   : 938.27
Neutron  : 939.57
Electron : 0.511
Muon     : 105.66
Neutron  : 939.57
Positron : 0.511
Proton   : 938.27
Tau      : 1776.86
Electron : 0.511
Positron : 0.511
Muon     : 105.66
Proton   : 938.27
Neutron  : 939.57
Tau      : 1776.86

Véase también