Namespaces
Variants

std:: sort

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Определено в заголовке <algorithm>
template < class RandomIt >
void sort ( RandomIt first, RandomIt last ) ;
(1) (constexpr since C++20)
template < class ExecutionPolicy, class RandomIt >

void sort ( ExecutionPolicy && policy,

RandomIt first, RandomIt last ) ;
(2) (since C++17)
template < class RandomIt, class Compare >
void sort ( RandomIt first, RandomIt last, Compare comp ) ;
(3) (constexpr since C++20)
template < class ExecutionPolicy, class RandomIt, class Compare >

void sort ( ExecutionPolicy && policy,

RandomIt first, RandomIt last, Compare comp ) ;
(4) (since C++17)

Сортирует элементы в диапазоне [ first , last ) в неубывающем порядке. Порядок равных элементов не гарантируется.

1) Элементы отсортированы относительно operator < (до C++20) std:: less { } (начиная с C++20) .
3) Элементы отсортированы относительно comp .
2,4) То же, что и (1,3) , но выполняется в соответствии с policy .
Эти перегрузки участвуют в разрешении перегрузки только при выполнении всех следующих условий:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> является true .

(до C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> является true .

(начиная с C++20)

Если выполняется любое из следующих условий, поведение не определено:

(до C++11)
(начиная с C++11)

Содержание

Параметры

first, last - пара итераторов, определяющих диапазон элементов для сортировки
policy - политика выполнения, которая будет использоваться
comp - функция сравнения (т.е. объект, удовлетворяющий требованиям Compare ), которая возвращает ​ true если первый аргумент меньше второго (т.е. упорядочен перед вторым).

Сигнатура функции сравнения должна быть эквивалентна следующей:

bool cmp ( const Type1 & a, const Type2 & b ) ;

Хотя сигнатура не обязана содержать const & , функция не должна модифицировать передаваемые ей объекты и должна быть способна принимать все значения типов (возможно const) Type1 и Type2 независимо от категории значения (следовательно, Type1& не допускается , как и Type1 , если для Type1 перемещение не эквивалентно копированию (since C++11) ).
Типы Type1 и Type2 должны быть такими, чтобы объект типа RandomIt мог быть разыменован и неявно преобразован к обоим из них. ​

Требования к типам
-
RandomIt должен удовлетворять требованиям LegacyRandomAccessIterator .
-
Compare должен удовлетворять требованиям Compare .

Сложность

Дано N как last - first :

1,2) O(N·log(N)) сравнений с использованием operator < (до C++20) std:: less { } (начиная с C++20) .
3,4) O(N·log(N)) применений компаратора comp .

Исключения

Перегрузки с параметром шаблона с именем ExecutionPolicy сообщают об ошибках следующим образом:

  • Если выполнение функции, вызванной как часть алгоритма, выбрасывает исключение и ExecutionPolicy является одним из стандартных политик , std::terminate вызывается. Для любой другой ExecutionPolicy поведение определяется реализацией.
  • Если алгоритму не удается выделить память, std::bad_alloc выбрасывается.

Возможная реализация

Смотрите также реализации в libstdc++ и libc++ .

Примечания

До LWG713 требование к сложности позволяло реализовывать sort() только с использованием Quicksort , который может требовать O(N 2
)
сравнений в худшем случае.

Introsort может обрабатывать все случаи с O(N·log(N)) сравнениями (без дополнительных накладных расходов в среднем случае), и поэтому обычно используется для реализации sort() .

libc++ не реализовала исправленное требование к временной сложности до LLVM 14 .

Пример

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

Вывод:

0 1 2 3 4 5 6 7 8 9 : sorted with the default operator<
9 8 7 6 5 4 3 2 1 0 : sorted with the standard library compare function object
0 1 2 3 4 5 6 7 8 9 : sorted with a custom function object
9 8 7 6 5 4 3 2 1 0 : sorted with a lambda expression

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Applied to Behavior as published Correct behavior
LWG 713 C++98 the O(N·log(N)) time complexity was only required on the average it is required for the worst case

Смотрите также

сортирует первые N элементов диапазона
(шаблон функции)
сортирует диапазон элементов, сохраняя порядок между равными элементами
(шаблон функции)
сортирует диапазон в порядке возрастания
(функциональный объект алгоритма)