std::ranges::stable_sort
From cppreference.com
| Defined in header <algorithm>
|
||
| Call signature |
||
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 = {} );
|
(1) | (since C++20) (constexpr since C++26) |
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 = {} );
|
(2) | (since C++20) (constexpr since C++26) |
template< /*execution-policy*/ Ep,
std::random_access_iterator I, std::sized_sentinel_for<I> S,
class Comp = ranges::less, class Proj = std::identity >
requires std::sortable<I, Comp, Proj>
I stable_sort( Ep&& policy, I first, S last,
Comp comp = {}, Proj proj = {} );
|
(3) | (since C++26) |
template< /*execution-policy*/ Ep, /*sized-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( Ep&& policy, R&& r, Comp comp = {}, Proj proj = {} );
|
(4) | (since C++26) |
For the definition of /*execution-policy*/, see this page; for the definition of /*sized-random-access-range*/, see this page.
1,2) Sorts the elements in the target range
[first, last) or r with respect to the comparator comp and projection proj. The order of equivalent elements is guaranteed to be preserved.3,4) Same as (1,2), but executed according to
policy.The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:
- Explicit template argument lists cannot be specified when calling any of them.
- None of them are visible to argument-dependent lookup.
- When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.
Parameters
| first, last | - | the iterator-sentinel pair defining the target range |
| r | - | the target range |
| comp | - | the comparator to be applied to the (projected) elements |
| proj | - | the projection to be applied to the elements |
| policy | - | the execution policy to use |
Return value
The past-the-end iterator of the target range.
Complexity
Given N as ranges::distance(first, last) or ranges::distance(r):
1-4) 𝓞(N·log2(N)) applications of
comp (or only 𝓞(N·log(N)) comparisons if enough extra memory is available), and twice as many applications of proj.Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_constexpr_algorithms |
202306L |
(C++26) | constexpr stable sorting
|
Possible implementation
This implementation only shows the slower algorithm used when no additional memory is available. See also implementation in MSVC STL and 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 //< since 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 //< since C++26
ranges::borrowed_iterator_t<R>
operator()(R&& r, Comp comp = {}, Proj proj = {}) const
{
return (*this)(ranges::begin(r),
ranges::next(ranges::begin(r), ranges::end(r)),
std::move(comp), std::move(proj));
}
};
inline constexpr stable_sort_fn stable_sort{};
|
Example
Run this code
#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};
// sort using the default operator<
std::ranges::stable_sort(s);
print(s);
// sort using a standard library compare function object
std::ranges::stable_sort(s, std::ranges::greater());
print(s);
// sort using a custom function object
struct
{
bool operator()(int a, int b) const { return a < b; }
} customLess;
std::ranges::stable_sort(s.begin(), s.end(), customLess);
print(s);
// sort using a lambda expression
std::ranges::stable_sort(s, [](int a, int b) { return a > b; });
print(s);
// sort with projection
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); //< sorts by name
print(particles);
std::ranges::stable_sort(particles, {}, &Particle::mass); //< sorts by mass
print(particles);
}
Output:
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
See also
| sorts a range of elements while preserving relative order between equivalent elements (function template) | |
(C++20) |
sorts a range of elements (algorithm function object) |
(C++20) |
sorts the first N elements of a range (algorithm function object) |
(C++20) |
divides elements into two groups while preserving their relative order within each group (algorithm function object) |