#include "tbb/parallel_sort.h"
template<typename RandomAccessIterator> void parallel_sort(RandomAccessIterator begin, RandomAccessIterator end); template<typename RandomAccessIterator, typename Compare> void parallel_sort(RandomAccessIterator begin, RandomAccessIterator end, const Compare& comp );
Performs an unstable sort of sequence [begin1, end1). An unstable sort might not preserve the relative ordering of elements with equal keys. The sort is deterministic; sorting the same sequence will produce the same result each time. The requirements on the iterator and sequence are the same as for std::sort . Specifically, RandomAccessIterator must be a random access iterator, and its value type T must model the requirements in the table below.
Pseudo-Signature |
Semantics |
---|---|
void swap( T& x, T& y ) |
Swap x and y . |
bool Compare::operator()( const T& x, const T& y ) |
True if x comes before y ; false otherwise. |
A call parallel_sort(i,j,comp) sorts the sequence [i,j) using the argument comp to determine relative orderings. If comp(x,y) returns true then x appears before y in the sorted sequence.
A call parallel_sort(i,j) is equivalent to parallel_sort(i,j,std::less<T>).
Complexity
parallel_sort is comparison sort with an average time complexity of O(N log (N)), where N is the number of elements in the sequence. When worker threads are available, parallel_sort creates subtasks that may be executed concurrently, leading to improved execution times.
Example
The following example shows two sorts. The sort of array a uses the default comparison, which sorts in ascending order. The sort of array b sorts in descending order by using std::greater<float> for comparison.
#include "tbb/parallel_sort.h" #include <math.h> using namespace tbb; const int N = 100000; float a[N]; float b[N]; void SortExample() { for( int i = 0; i < N; i++ ) { a[i] = sin((double)i); b[i] = cos((double)i); } parallel_sort(a, a + N); parallel_sort(b, b + N, std::greater<float>()); }