Namespaces
Variants

std:: inplace_merge

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)
inplace_merge
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Определено в заголовке <algorithm>
template < class BidirIt >
void inplace_merge ( BidirIt first, BidirIt middle, BidirIt last ) ;
(1) (constexpr начиная с C++26)
template < class ExecutionPolicy, class BidirIt >

void inplace_merge ( ExecutionPolicy && policy,

BidirIt first, BidirIt middle, BidirIt last ) ;
(2) (начиная с C++17)
template < class BidirIt, class Compare >

void inplace_merge ( BidirIt first, BidirIt middle, BidirIt last,

Compare comp ) ;
(3) (constexpr начиная с C++26)
template < class ExecutionPolicy, class BidirIt, class Compare >

void inplace_merge ( ExecutionPolicy && policy,
BidirIt first, BidirIt middle, BidirIt last,

Compare comp ) ;
(4) (начиная с C++17)

Объединяет два последовательных отсортированных диапазона [ first , middle ) и [ middle , last ) в один отсортированный диапазон [ first , last ) .

1) Если [ first , middle ) или [ middle , last ) не являются отсортированными относительно operator < (до C++20) std:: less { } (начиная с C++20) , поведение не определено.
3) Если [ first , middle ) или [ middle , last ) не отсортирован относительно 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 - начало первого отсортированного диапазона
middle - конец первого отсортированного диапазона и начало второго
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 должны быть такими, чтобы объект типа BidirIt мог быть разыменован и неявно преобразован к обоим из них. ​

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

Сложность

Дано N как std:: distance ( first, last ) :

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

Исключения

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

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

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

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

Примечания

Эта функция пытается выделить временный буфер. Если выделение завершается неудачей, выбирается менее эффективный алгоритм.

Макрос тестирования возможностей Значение Стандарт Возможность
__cpp_lib_constexpr_algorithms 202306L (C++26) constexpr inplace слияние ( 1 ) , ( 3 )

Пример

Следующий код представляет реализацию сортировки слиянием.

#include <algorithm>
#include <iostream>
#include <vector>
template<class Iter>
void merge_sort(Iter first, Iter last)
{
    if (last - first > 1)
    {
        Iter middle = first + (last - first) / 2;
        merge_sort(first, middle);
        merge_sort(middle, last);
        std::inplace_merge(first, middle, last);
    }
}
int main()
{
    std::vector<int> v{8, 2, -2, 0, 11, 11, 1, 7, 3};
    merge_sort(v.begin(), v.end());
    for (const auto& n : v)
        std::cout << n << ' ';
    std::cout << '\n';
}

Вывод:

-2 0 1 2 3 7 8 11 11

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

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