parallel_sort

[algorithms.parallel_sort]

Function template that sorts a sequence.

// Defined in header <oneapi/tbb/parallel_sort.h>

namespace oneapi {
    namespace tbb {

        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 );

        template<typename Container>
        void parallel_sort( Container&& c );
        template<typename Container>
        void parallel_sort( Container&& c, const Compare& comp );

    } //  namespace tbb
} // namespace oneapi

Requirements:

• The RandomAccessIterator type must meet the Random Access Iterators requirements from [random.access.iterators] and ValueSwappable requirements from the [swappable.requirements] ISO C++ Standard section.

• The Compare type must meet the Compare type requirements from the [alg.sorting] ISO C++ Standard section.

• The Container type must meet the ContainerBasedSequence requirements which iterators must meet the Random Access Iterators requirements from [random.access.iterators] and Swappable requirements from the [swappable.requirements] ISO C++ Standard section.

• The type of dereferenced RandomAccessIterator or dereferenced Container iterator must meet the MoveAssignable requirements from [moveassignable] section of ISO C++ Standard and the MoveConstructible requirements from [moveconstructible] section of ISO C++ Standard.

Sorts a sequence or a container. The sort is neither stable nor deterministic: relative ordering of elements with equal keys is not preserved and not guaranteed to repeat if the same sequence is sorted again.

A call parallel_sort( begin, end, comp ) sorts the sequence [begin, end) using the argument comp to determine relative orderings. If comp( x, y ) returns true, x appears before y in the sorted sequence.

A call parallel_sort( begin, end ) is equivalent to parallel_sort( begin, end, comp ), where comp uses operator< to determine relative orderings.

A call parallel_sort( c, comp ) is equivalent to parallel_sort( std::begin(c), std::end(c), comp ).

A call parallel_sort( c ) is equivalent to parallel_sort( c, comp ), where comp uses operator< to determine relative orderings.

Complexity

parallel_sort is a comparison sort with an average time complexity of O(N×log(N)), where N is the number of elements in the sequence. parallel_sort may be executed concurrently to improve execution time.