std::ranges::partial_sort_copy, std::ranges::partial_sort_copy_result
Depuis fr.cppreference.net
| Défini dans l'en-tête <algorithm>
|
||
| Signature d'appel |
||
template< std::input_iterator I1, std::sentinel_for<I1> S1,
std::random_access_iterator I2, std::sentinel_for<I2> S2,
class Comp = ranges::less, class Proj1 = std::identity,
class Proj2 = std::identity >
requires std::indirectly_copyable<I1, I2> &&
std::sortable<I2, Comp, Proj2> &&
std::indirect_strict_weak_order<Comp, std::projected<I1, Proj1>,
std::projected<I2, Proj2>>
constexpr partial_sort_copy_result<I1, I2>
partial_sort_copy( I1 first, S1 last, I2 result_first, S2 result_last,
Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );
|
(1) | (depuis C++20) |
template< ranges::input_range R1, ranges::random_access_range R2,
class Comp = ranges::less, class Proj1 = std::identity,
class Proj2 = std::identity >
requires std::indirectly_copyable<ranges::iterator_t<R1>, ranges::iterator_t<R2>> &&
std::sortable<ranges::iterator_t<R2>, Comp, Proj2> &&
std::indirect_strict_weak_order<Comp, std::projected<ranges::iterator_t<R1>,
Proj1>, std::projected<ranges::iterator_t<R2>, Proj2>>
constexpr partial_sort_copy_result<ranges::borrowed_iterator_t<R1>,
ranges::borrowed_iterator_t<R2>>
partial_sort_copy( R1&& r, R2&& result_r,
Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );
|
(2) | (depuis C++20) |
| Types auxiliaires |
||
template< class I, class O >
using partial_sort_copy_result = ranges::in_out_result<I, O>;
|
(3) | (depuis C++20) |
Copie les premiers N éléments de la plage source [first, last), comme si elle était partiellement triée par rapport à comp et proj1, dans la plage de destination [result_first, result_first + N), où N = min(L₁, L₂), L₁ est égal à ranges::distance(first, last), et L₂ est égal à ranges::distance(result_first, result_last).
L'ordre des éléments égaux n'est pas garanti d'être préservé.
1) Les éléments de la plage source sont projetés à l'aide de l'objet fonction
proj1, et les éléments de destination sont projetés à l'aide de l'objet fonction proj2.2) Identique à (1), mais utilise
r comme plage source et result_r comme plage de destination, comme si en utilisant ranges::begin(r) comme first, ranges::end(r) comme last, ranges::begin(result_r) comme result_first, et ranges::end(result_r) comme result_last.Les entités de type fonction décrites sur cette page sont des objets fonctions algorithmes (informellement appelés niebloids), c'est-à-dire :
- Les listes d'arguments de template explicites ne peuvent pas être spécifiées lors de l'appel à l'un d'entre eux.
- Aucun d'entre eux n'est visible par la recherche dépendante des arguments (ADL).
- Lorsque l'un d'entre eux est trouvé par une recherche non qualifiée normale comme le nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments (ADL) est inhibée.
Paramètres
| first, last | - | la paire itérateur-sentinelle définissant la plage source des éléments à copier |
| r | - | la plage source à copier |
| result_first, result_last | - | la paire itérateur-sentinelle définissant la plage de destination des éléments |
| result_r | - | la plage de destination |
| comp | - | comparaison à appliquer aux éléments projetés |
| proj1 | - | projection à appliquer aux éléments de la plage source |
| proj2 | - | projection à appliquer aux éléments de la plage de destination |
Valeur de retour
Un objet égal à { last, result_first + N } .
Complexité
Au maximum L₁•log(N) comparaisons et 2•L₁•log(N) projections.
Implémentation possible
struct partial_sort_copy_fn { template<std::input_iterator I1, std::sentinel_for<I1> S1, std::random_access_iterator I2, std::sentinel_for<I2> S2, class Comp = ranges::less, class Proj1 = std::identity, class Proj2 = std::identity> requires std::indirectly_copyable<I1, I2> && std::sortable<I2, Comp, Proj2> && std::indirect_strict_weak_order<Comp, std::projected<I1, Proj1>, std::projected<I2, Proj2>> constexpr ranges::partial_sort_copy_result<I1, I2> operator()(I1 first, S1 last, I2 result_first, S2 result_last, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const { if (result_first == result_last) return {std::move(ranges::next(std::move(first), std::move(last))), std::move(result_first)}; auto out_last{result_first}; // copier les N premiers éléments for (; !(first == last or out_last == result_last); ++out_last, ++first) *out_last = *first; // convertir N éléments copiés en un tas-max ranges::make_heap(result_first, out_last, comp, proj2); // traiter le reste de la plage d'entrée (s'il y en a), en préservant la propriété de tas for (; first != last; ++first) { if (std::invoke(comp, std::invoke(proj1, *first), std::invoke(proj2, *result_first))) { // extraire l'élément le plus grand et insérer un nouvel élément plus petit trouvé ranges::pop_heap(result_first, out_last, comp, proj2); *(out_last - 1) = *first; ranges::push_heap(result_first, out_last, comp, proj2); } } // les N premiers éléments dans la plage de sortie sont toujours // un tas - convertissez-le en une plage triée ranges::sort_heap(result_first, out_last, comp, proj2); return {std::move(first), std::move(out_last)}; } template<ranges::input_range R1, ranges::random_access_range R2, class Comp = ranges::less, class Proj1 = std::identity, class Proj2 = std::identity> requires std::indirectly_copyable<ranges::iterator_t<R1>, ranges::iterator_t<R2>> && std::sortable<ranges::iterator_t<R2>, Comp, Proj2> && std::indirect_strict_weak_order<Comp, std::projected<ranges::iterator_t<R1>, Proj1>, std::projected<ranges::iterator_t<R2>, Proj2>> constexpr ranges::partial_sort_copy_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>> operator()(R1&& r, R2&& result_r, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const { return (*this)(ranges::begin(r), ranges::end(r), ranges::begin(result_r), ranges::end(result_r), std::move(comp), std::move(proj1), std::move(proj2)); } }; inline constexpr partial_sort_copy_fn partial_sort_copy {}; |
Exemple
Exécuter ce code
#include <algorithm> #include <forward_list> #include <functional> #include <iostream> #include <ranges> #include <string_view> #include <vector> void print(std::string_view rem, std::ranges::input_range auto const& v) { for (std::cout << rem; const auto& e : v) std::cout << e << ' '; std::cout << '\n'; } int main() { const std::forward_list source{4, 2, 5, 1, 3}; print("Écrire dans le vecteur plus petit en ordre croissant : ", ""); std::vector dest1{10, 11, 12}; print("liste source constante : ", source); print("plage de destination : ", dest1); std::ranges::partial_sort_copy(source, dest1); print("partial_sort_copy : ", dest1); print("Écrire dans le vecteur plus grand en ordre décroissant :", ""); std::vector dest2{10, 11, 12, 13, 14, 15, 16}; print("liste source constante : ", source); print("plage de destination : ", dest2); std::ranges::partial_sort_copy(source, dest2, std::greater{}); print("partial_sort_copy : ", dest2); }
Sortie :
Écrire dans le vecteur plus petit en ordre croissant : liste source constante : 4 2 5 1 3 plage de destination : 10 11 12 partial_sort_copy : 1 2 3 Écrire dans le vecteur plus grand en ordre décroissant : liste source constante : 4 2 5 1 3 plage de destination : 10 11 12 13 14 15 16 partial_sort_copy : 5 4 3 2 1 15 16
Voir aussi
(C++20) |
trie les N premiers éléments d'une plage (objet fonction d'algorithme) |
(C++20) |
trie les éléments d'une plage (objet fonction d'algorithme) |
(C++20) |
trie les éléments d'une plage tout en préservant l'ordre relatif des éléments équivalents (objet fonction d'algorithme) |
(C++20) |
transforme un tas max en une plage triée d'éléments (objet fonction d'algorithme) |
(C++20) |
crée un tas max à partir d'une plage d'éléments (objet fonction d'algorithme) |
(C++20) |
ajoute un élément à un tas max (objet fonction d'algorithme) |
(C++20) |
supprime le plus grand élément d'un tas max (objet fonction d'algorithme) |
| copie et trie partiellement les éléments d'une plage (modèle de fonction) |