std::sort

Defined in header <algorithm>

template< class RandomIt >
void sort( RandomIt first, RandomIt last );

(1)

template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );

(2)

Sorts the elements in the range [first, last) in ascending order. The order of equal elements is not guaranteed to be preserved. The first version uses operator< to compare the elements, the second version uses the given comparison function object comp.

Parameters

first, last	-	the range of elements to sort
comp	-	comparison function object (i.e. an object that satisfies the requirements of `Compare`) which returns `true` if the first argument is less than (i.e. is ordered before) the second. The signature of the comparison function should be equivalent to the following: `bool cmp(const Type1 &a, const Type2 &b);` The signature does not need to have `const &`, but the function object must not modify the objects passed to it. The types `Type1` and `Type2` must be such that an object of type `RandomIt` can be dereferenced and then implicitly converted to both of them.
Type requirements
- `RandomIt` must meet the requirements of `ValueSwappable` and `RandomAccessIterator`.
-The type of dereferenced `RandomIt` must meet the requirements of `MoveAssignable` and `MoveConstructible`.
- `Compare` must meet the requirements of `Compare`.

Return value

(none).

Complexity

O(N·log(N)), where `N = std::distance(first, last)` comparisons on average.	(until C++11)
O(N·log(N)), where `N = std::distance(first, last)` comparisons.	(since C++11)

Example

#include <algorithm>
#include <functional>
#include <array>
#include <iostream>
  
int main()
{
    std::array<int, 10> s = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3}; 
  
    // sort using the default operator<
    std::sort(s.begin(), s.end());
    for (int a : s) {
        std::cout << a << " ";
    }   
    std::cout << '\n';
  
    // sort using a standard library compare function object
    std::sort(s.begin(), s.end(), std::greater<int>());
    for (int a : s) {
        std::cout << a << " ";
    }   
    std::cout << '\n';
  
    // sort using a custom function object
    struct {
        bool operator()(int a, int b)
        {   
            return a < b;
        }   
    } customLess;
    std::sort(s.begin(), s.end(), customLess);
    for (int a : s) {
        std::cout << a << " ";
    }   
    std::cout << '\n';
  
    // sort using a lambda expression 
    std::sort(s.begin(), s.end(), [](int a, int b) {
        return b < a;   
    });
    for (int a : s) {
        std::cout << a << " ";
    } 
    std::cout << '\n';
}

Output:

1 2 3 4 5 6 7 8 9 
8 7 6 5 4 3 2 1 0 
1 2 3 4 5 6 7 8 9 
8 7 6 5 4 3 2 1 0

partial_sort	sorts the first N elements of a range (function template)
stable_sort	sorts a range of elements while preserving order between equal elements (function template)
std::experimental::parallel::sort (parallelism TS)	parallelized version of `std::sort` (function template)

std::sort

Parameters

Return value

Complexity

Example

See also