thrust::stable_sort#

Overloads#

stable_sort(exec, first, last)#

template<typename DerivedPolicy, typename RandomAccessIterator>
void thrust::stable_sort(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
RandomAccessIterator first,
RandomAccessIterator last,
)#

stable_sort is much like sort: it sorts the elements in [first, last) into ascending order, meaning that if i and j are any two valid iterators in [first, last) such that i precedes j, then *j is not less than *i.

As the name suggests, stable_sort is stable: it preserves the relative ordering of equivalent elements. That is, if x and y are elements in [first, last) such that x precedes y, and if the two elements are equivalent (neither x < y nor y < x) then a postcondition of stable_sort is that x still precedes y.

This version of stable_sort compares objects using operator<.

The algorithm’s execution is parallelized as determined by exec.

The following code snippet demonstrates how to use sort to sort a sequence of integers using the thrust::host execution policy for parallelization:

#include <thrust/sort.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::stable_sort(thrust::host, A, A + N);
// A is now {1, 2, 4, 5, 7, 8}

See also

https://en.cppreference.com/w/cpp/algorithm/stable_sort

See also

sort

See also

stable_sort_by_key

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the sequence.

  • last – The end of the sequence.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • RandomAccessIterator – is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements.

stable_sort(first, last)#

template<typename RandomAccessIterator>
void thrust::stable_sort(
RandomAccessIterator first,
RandomAccessIterator last,
)#

stable_sort is much like sort: it sorts the elements in [first, last) into ascending order, meaning that if i and j are any two valid iterators in [first, last) such that i precedes j, then *j is not less than *i.

As the name suggests, stable_sort is stable: it preserves the relative ordering of equivalent elements. That is, if x and y are elements in [first, last) such that x precedes y, and if the two elements are equivalent (neither x < y nor y < x) then a postcondition of stable_sort is that x still precedes y.

This version of stable_sort compares objects using operator<.

The following code snippet demonstrates how to use sort to sort a sequence of integers.

#include <thrust/sort.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::stable_sort(A, A + N);
// A is now {1, 2, 4, 5, 7, 8}

See also

https://en.cppreference.com/w/cpp/algorithm/stable_sort

See also

sort

See also

stable_sort_by_key

Parameters:

  • first – The beginning of the sequence.

  • last – The end of the sequence.

Template Parameters:

RandomAccessIterator – is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is a model of LessThan Comparable, and the ordering relation on RandomAccessIterator's value_type is a strict weak ordering, as defined in the LessThan Comparable requirements.

stable_sort(exec, first, last, comp)#

template<typename DerivedPolicy, typename RandomAccessIterator, typename StrictWeakOrdering>
void thrust::stable_sort(
const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
RandomAccessIterator first,
RandomAccessIterator last,
StrictWeakOrdering comp,
)#

stable_sort is much like sort: it sorts the elements in [first, last) into ascending order, meaning that if i and j are any two valid iterators in [first, last) such that i precedes j, then *j is not less than *i.

As the name suggests, stable_sort is stable: it preserves the relative ordering of equivalent elements. That is, if x and y are elements in [first, last) such that x precedes y, and if the two elements are equivalent (neither x < y nor y < x) then a postcondition of stable_sort is that x still precedes y.

This version of stable_sort compares objects using a function object comp.

The algorithm’s execution is parallelized as determined by exec.

The following code demonstrates how to sort integers in descending order using the greater<int> comparison operator using the thrust::host execution policy for parallelization:

#include <thrust/sort.h>
#include <thrust/functional.h>
#include <thrust/execution_policy.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(A, A + N, ::cuda::std::greater<int>());
// A is now {8, 7, 5, 4, 2, 1};

See also

https://en.cppreference.com/w/cpp/algorithm/stable_sort

See also

sort

See also

stable_sort_by_key

Parameters:

  • exec – The execution policy to use for parallelization.

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • comp – Comparison operator.

Template Parameters:

  • DerivedPolicy – The name of the derived execution policy.

  • RandomAccessIterator – is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is convertible to StrictWeakOrdering's first argument type and second argument type.

  • StrictWeakOrdering – is a model of Strict Weak Ordering.

stable_sort(first, last, comp)#

template<typename RandomAccessIterator, typename StrictWeakOrdering>
void thrust::stable_sort(
RandomAccessIterator first,
RandomAccessIterator last,
StrictWeakOrdering comp,
)#

stable_sort is much like sort: it sorts the elements in [first, last) into ascending order, meaning that if i and j are any two valid iterators in [first, last) such that i precedes j, then *j is not less than *i.

As the name suggests, stable_sort is stable: it preserves the relative ordering of equivalent elements. That is, if x and y are elements in [first, last) such that x precedes y, and if the two elements are equivalent (neither x < y nor y < x) then a postcondition of stable_sort is that x still precedes y.

This version of stable_sort compares objects using a function object comp.

The following code demonstrates how to sort integers in descending order using the greater<int> comparison operator.

#include <thrust/sort.h>
#include <thrust/functional.h>
...
const int N = 6;
int A[N] = {1, 4, 2, 8, 5, 7};
thrust::sort(A, A + N, ::cuda::std::greater<int>());
// A is now {8, 7, 5, 4, 2, 1};

See also

https://en.cppreference.com/w/cpp/algorithm/stable_sort

See also

sort

See also

stable_sort_by_key

Parameters:

  • first – The beginning of the sequence.

  • last – The end of the sequence.

  • comp – Comparison operator.

Template Parameters:

  • RandomAccessIterator – is a model of Random Access Iterator, RandomAccessIterator is mutable, and RandomAccessIterator's value_type is convertible to StrictWeakOrdering's first argument type and second argument type.

  • StrictWeakOrdering – is a model of Strict Weak Ordering.