View source for cpp/algorithm

You do not have permission to edit this page, for the following reasons:
The action you have requested is limited to users in one of the groups: Users, Administrators.
Due to recent vandalism, editing of this page is temporarily disabled for new users.If you want to suggest a change, please leave a message on the suggestions page for new users instead (don't be surprised if that page appears vandalized!).
You can view and copy the source of this page.
{{title|Algorithms library}}
{{cpp/algorithm/navbar}}

The algorithms library defines functions for a variety of purposes (e.g. searching, sorting, counting, manipulating) that operate on ranges of elements. Note that a [[cpp/iterator#Ranges|range]] is defined as {{range|first|last}} where {{c|last}} refers to the element ''past'' the last element to inspect or modify.

{{anchor|Constrained algorithms}}
==={{rl|ranges|Constrained algorithms}} {{mark since c++20}}===
C++20 provides [[cpp/language/constraints|constrained]] versions of most algorithms in the namespace {{tt|std::ranges}}. In these algorithms, a [[cpp/iterator#Ranges|range]] can be specified as either an [[cpp/iterator/input_or_output_iterator|iterator]]-[[cpp/iterator/sentinel_for|sentinel]] pair or as a single {{lconcept|range}} argument, and projections and pointer-to-member callables are supported. Additionally, the {{lsd|cpp/algorithm/ranges#Return types}} of most algorithms have been changed to return all potentially useful information computed during the execution of the algorithm.
{{source|1=
std::vector<int> v{7, 1, 4, 0, -1};
std::ranges::sort(v); // constrained algorithm
}}

{{anchor|Execution policies}}
===Execution policies {{mark since c++17}}===
Most algorithms have overloads that accept execution policies. The standard library algorithms support several [[cpp/algorithm/execution_policy_tag_t|execution policies]], and the library provides corresponding execution policy types and objects. Users may select an execution policy statically by invoking a parallel algorithm with an [[cpp/algorithm/execution_policy_tag|execution policy object]] of the corresponding type.

Standard library implementations (but not the users) may define additional execution policies as an extension. The semantics of parallel algorithms invoked with an execution policy object of implementation-defined type is implementation-defined.

Parallel version of algorithms (except for {{lc|std::for_each}} and {{lc|std::for_each_n}}) are allowed to make arbitrary copies of elements from ranges, as long as both {{c|std::is_trivially_copy_constructible_v<T>}} and {{c|std::is_trivially_destructible_v<T>}} are {{c|true}}, where {{tt|T}} is the type of elements.

{{dsc begin}}
{{dsc header|execution}}
{{dsc namespace|std::execution}}
{{dsc inc|cpp/algorithm/dsc execution_policy_tag_t}}
{{dsc inc|cpp/algorithm/dsc execution_policy_tag}}
{{dsc namespace|std}}
{{dsc inc|cpp/algorithm/dsc is_execution_policy}}
{{dsc end}}
{{ftm begin|std=1|comment=1}}
{{ftm|__cpp_lib_parallel_algorithm|Parallel algorithms|std=C++17|value=201603L}}
{{ftm|__cpp_lib_execution|rowspan=2|Execution policies|std=C++17|value=201603L}}
{{ftm|-|{{lc|std::execution::unsequenced_policy}}|std=C++20|value=201902L}}
{{ftm end}}

===Non-modifying sequence operations===
====Batch operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc for_each}}
{{dsc inc|cpp/algorithm/ranges/dsc for_each}}
{{dsc inc|cpp/algorithm/dsc for_each_n}}
{{dsc inc|cpp/algorithm/ranges/dsc for_each_n}}
{{dsc end}}

====Search operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc all_any_none_of}}
{{dsc inc|cpp/algorithm/ranges/dsc all_any_none_of}}
{{dsc inc|cpp/algorithm/ranges/dsc contains}}
{{dsc inc|cpp/algorithm/dsc find}}
{{dsc inc|cpp/algorithm/ranges/dsc find}}
{{dsc inc|cpp/algorithm/ranges/dsc find_last}}
{{dsc inc|cpp/algorithm/dsc find_end}}
{{dsc inc|cpp/algorithm/ranges/dsc find_end}}
{{dsc inc|cpp/algorithm/dsc find_first_of}}
{{dsc inc|cpp/algorithm/ranges/dsc find_first_of}}
{{dsc inc|cpp/algorithm/dsc adjacent_find}}
{{dsc inc|cpp/algorithm/ranges/dsc adjacent_find}}
{{dsc inc|cpp/algorithm/dsc count}}
{{dsc inc|cpp/algorithm/ranges/dsc count}}
{{dsc inc|cpp/algorithm/dsc mismatch}}
{{dsc inc|cpp/algorithm/ranges/dsc mismatch}}
{{dsc inc|cpp/algorithm/dsc equal}}
{{dsc inc|cpp/algorithm/ranges/dsc equal}}
{{dsc inc|cpp/algorithm/dsc search}}
{{dsc inc|cpp/algorithm/ranges/dsc search}}
{{dsc inc|cpp/algorithm/dsc search_n}}
{{dsc inc|cpp/algorithm/ranges/dsc search_n}}
{{dsc inc|cpp/algorithm/ranges/dsc starts_with}}
{{dsc inc|cpp/algorithm/ranges/dsc ends_with}}
{{dsc end}}

{{anchor|Fold operations}}
====Fold operations {{mark since c++23}}====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/ranges/dsc fold_left}}
{{dsc inc|cpp/algorithm/ranges/dsc fold_left_first}}
{{dsc inc|cpp/algorithm/ranges/dsc fold_right}}
{{dsc inc|cpp/algorithm/ranges/dsc fold_right_last}}
{{dsc inc|cpp/algorithm/ranges/dsc fold_left_with_iter}}
{{dsc inc|cpp/algorithm/ranges/dsc fold_left_first_with_iter}}
{{dsc end}}

===Modifying sequence operations===
====Copy operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc copy}}
{{dsc inc|cpp/algorithm/ranges/dsc copy}}
{{dsc inc|cpp/algorithm/dsc copy_n}}
{{dsc inc|cpp/algorithm/ranges/dsc copy_n}}
{{dsc inc|cpp/algorithm/dsc copy_backward}}
{{dsc inc|cpp/algorithm/ranges/dsc copy_backward}}
{{dsc inc|cpp/algorithm/dsc move}}
{{dsc inc|cpp/algorithm/ranges/dsc move}}
{{dsc inc|cpp/algorithm/dsc move_backward}}
{{dsc inc|cpp/algorithm/ranges/dsc move_backward}}
{{dsc end}}

====Swap operations====
{{dsc begin}}
{{dsc header|algorithm|{{nbspt|3}}{{mark until c++11}}}}
{{dsc header|utility|{{nbspt|5}}{{mark since c++11}}}}
{{dsc header|string_view}}
{{dsc inc|cpp/algorithm/dsc swap}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc swap_ranges}}
{{dsc inc|cpp/algorithm/ranges/dsc swap_ranges}}
{{dsc inc|cpp/algorithm/dsc iter_swap}}
{{dsc end}}

====Transformation operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc transform}}
{{dsc inc|cpp/algorithm/ranges/dsc transform}}
{{dsc inc|cpp/algorithm/dsc replace}}
{{dsc inc|cpp/algorithm/ranges/dsc replace}}
{{dsc inc|cpp/algorithm/dsc replace_copy}}
{{dsc inc|cpp/algorithm/ranges/dsc replace_copy}}
{{dsc end}}

====Generation operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc fill}}
{{dsc inc|cpp/algorithm/ranges/dsc fill}}
{{dsc inc|cpp/algorithm/dsc fill_n}}
{{dsc inc|cpp/algorithm/ranges/dsc fill_n}}
{{dsc inc|cpp/algorithm/dsc generate}}
{{dsc inc|cpp/algorithm/ranges/dsc generate}}
{{dsc inc|cpp/algorithm/dsc generate_n}}
{{dsc inc|cpp/algorithm/ranges/dsc generate_n}}
{{dsc end}}

====Removing operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc remove}}
{{dsc inc|cpp/algorithm/ranges/dsc remove}}
{{dsc inc|cpp/algorithm/dsc remove_copy}}
{{dsc inc|cpp/algorithm/ranges/dsc remove_copy}}
{{dsc inc|cpp/algorithm/dsc unique}}
{{dsc inc|cpp/algorithm/ranges/dsc unique}}
{{dsc inc|cpp/algorithm/dsc unique_copy}}
{{dsc inc|cpp/algorithm/ranges/dsc unique_copy}}
{{dsc end}}

====Order-changing operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc reverse}}
{{dsc inc|cpp/algorithm/ranges/dsc reverse}}
{{dsc inc|cpp/algorithm/dsc reverse_copy}}
{{dsc inc|cpp/algorithm/ranges/dsc reverse_copy}}
{{dsc inc|cpp/algorithm/dsc rotate}}
{{dsc inc|cpp/algorithm/ranges/dsc rotate}}
{{dsc inc|cpp/algorithm/dsc rotate_copy}}
{{dsc inc|cpp/algorithm/ranges/dsc rotate_copy}}
{{dsc inc|cpp/algorithm/dsc shift}}
{{dsc inc|cpp/algorithm/ranges/dsc shift}}
{{dsc inc|cpp/algorithm/dsc random_shuffle}}
{{dsc inc|cpp/algorithm/ranges/dsc shuffle}}
{{dsc end}}

====Sampling operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc sample}}
{{dsc inc|cpp/algorithm/ranges/dsc sample}}
{{dsc end}}

===Sorting and related operations===
====Requirements====
Some algorithms require the sequence represented by the arguments to be “sorted” or “partitioned”. The behavior is undefined if the requirement is not met.

{{rev begin}}
{{rev|until=c++20|
A sequence is ''sorted with respect to a comparator {{c|comp}}'' if for every iterator {{c|iter}} pointing to the sequence and every non-negative integer {{c|n}} such that {{c|iter + n}}<ref name="plus">{{c|iter + n}} simply means “the result of {{c|iter}} being incremented {{c|n}} times”, regardless of whether {{c|iter}} is a random access iterator.</ref> is a {{rlp|iterator#Dereferenceability and validity|valid iterator}} pointing to an element of the sequence, {{c|1=comp(*(iter + n), *iter) == false}}<ref name="plus" />.
}}
{{rev|since=c++20|
A sequence is ''sorted with respect to {{c|comp}} and {{c|proj}}'' for a comparator {{c|comp}} and projection {{c|proj}} if for every iterator {{c|iter}} pointing to the sequence and every non-negative integer {{c|n}} such that {{c|iter + n}}<ref name="plus" /> is a valid iterator pointing to an element of the sequence, {{c multi|bool(std::invoke(comp, std::invoke(proj, *(iter + n)),|                       std::invoke(proj, *iter)))}}<ref name="plus" /> is {{c|false}}.

A sequence is ''sorted with respect to a comparator {{c|comp}}'' if the sequence is sorted with respect to {{c|comp}} and {{c|std::identity{}<!---->}} (the identity projection).
}}
{{rev end}}

A sequence {{range|start|finish}} is ''partitioned with respect to an expression {{c|f(e)}}'' if there exists an integer {{c|n}} such that for all {{c|i}} in {{range|0|std::distance(start, finish)}}, {{c|f(*(start + i))}}<ref name="plus" /> is {{c|true}} if and only if {{c|i < n}}.

<references/>

====Partitioning operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc is_partitioned}}
{{dsc inc|cpp/algorithm/ranges/dsc is_partitioned}}
{{dsc inc|cpp/algorithm/dsc partition}}
{{dsc inc|cpp/algorithm/ranges/dsc partition}}
{{dsc inc|cpp/algorithm/dsc partition_copy}}
{{dsc inc|cpp/algorithm/ranges/dsc partition_copy}}
{{dsc inc|cpp/algorithm/dsc stable_partition}}
{{dsc inc|cpp/algorithm/ranges/dsc stable_partition}}
{{dsc inc|cpp/algorithm/dsc partition_point}}
{{dsc inc|cpp/algorithm/ranges/dsc partition_point}}
{{dsc end}}

====Sorting operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc sort}}
{{dsc inc|cpp/algorithm/ranges/dsc sort}}
{{dsc inc|cpp/algorithm/dsc stable_sort}}
{{dsc inc|cpp/algorithm/ranges/dsc stable_sort}}
{{dsc inc|cpp/algorithm/dsc partial_sort}}
{{dsc inc|cpp/algorithm/ranges/dsc partial_sort}}
{{dsc inc|cpp/algorithm/dsc partial_sort_copy}}
{{dsc inc|cpp/algorithm/ranges/dsc partial_sort_copy}}
{{dsc inc|cpp/algorithm/dsc is_sorted}}
{{dsc inc|cpp/algorithm/ranges/dsc is_sorted}}
{{dsc inc|cpp/algorithm/dsc is_sorted_until}}
{{dsc inc|cpp/algorithm/ranges/dsc is_sorted_until}}
{{dsc inc|cpp/algorithm/dsc nth_element}}
{{dsc inc|cpp/algorithm/ranges/dsc nth_element}}
{{dsc end}}

====Binary search operations (on partitioned ranges)====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc lower_bound}}
{{dsc inc|cpp/algorithm/ranges/dsc lower_bound}}
{{dsc inc|cpp/algorithm/dsc upper_bound}}
{{dsc inc|cpp/algorithm/ranges/dsc upper_bound}}
{{dsc inc|cpp/algorithm/dsc equal_range}}
{{dsc inc|cpp/algorithm/ranges/dsc equal_range}}
{{dsc inc|cpp/algorithm/dsc binary_search}}
{{dsc inc|cpp/algorithm/ranges/dsc binary_search}}
{{dsc end}}

====Set operations (on sorted ranges)====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc includes}}
{{dsc inc|cpp/algorithm/ranges/dsc includes}}
{{dsc inc|cpp/algorithm/dsc set_union}}
{{dsc inc|cpp/algorithm/ranges/dsc set_union}}
{{dsc inc|cpp/algorithm/dsc set_intersection}}
{{dsc inc|cpp/algorithm/ranges/dsc set_intersection}}
{{dsc inc|cpp/algorithm/dsc set_difference}}
{{dsc inc|cpp/algorithm/ranges/dsc set_difference}}
{{dsc inc|cpp/algorithm/dsc set_symmetric_difference}}
{{dsc inc|cpp/algorithm/ranges/dsc set_symmetric_difference}}
{{dsc end}}

====Merge operations (on sorted ranges)====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc merge}}
{{dsc inc|cpp/algorithm/ranges/dsc merge}}
{{dsc inc|cpp/algorithm/dsc inplace_merge}}
{{dsc inc|cpp/algorithm/ranges/dsc inplace_merge}}
{{dsc end}}

====Heap operations====
{{rev begin}}
{{rev|until=c++20|
A random access [[cpp/iterator#Ranges|range]] {{range|first|last}} is a ''heap with respect to a comparator {{c|comp}}'' if {{c|bool(comp(first[(i - 1) / 2], first[i]))}} is {{c|false}} for all integer {{c|i}} in {{open range|0|last - first}}.
}}
{{rev|since=c++20|
A random access [[cpp/iterator#Ranges|range]] {{range|first|last}} is a ''heap with respect to {{c|comp}} and {{c|proj}}'' for a comparator {{c|comp}} and projection {{c|proj}} if {{c multi|bool(std::invoke(comp, std::invoke(proj, first[(i - 1) / 2]),|                       std::invoke(proj, first[i]))}} is {{c|false}} for all integer {{c|i}} in {{open range|0|last - first}}.

A random access [[cpp/iterator#Ranges|range]] {{range|first|last}} is a ''heap with respect to a comparator {{c|comp}}'' if the range is a heap with respect to {{c|comp}} and {{c|std::identity{}<!---->}} (the identity projection).
}}
{{rev end}}

A heap can be created by {{lc|std::make_heap}}{{rev inl|since=c++20| and {{lc|ranges::make_heap}}}}.

For more properties of heap, see {{enwiki|Binary heap|max heap}}.


{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc push_heap}}
{{dsc inc|cpp/algorithm/ranges/dsc push_heap}}
{{dsc inc|cpp/algorithm/dsc pop_heap}}
{{dsc inc|cpp/algorithm/ranges/dsc pop_heap}}
{{dsc inc|cpp/algorithm/dsc make_heap}}
{{dsc inc|cpp/algorithm/ranges/dsc make_heap}}
{{dsc inc|cpp/algorithm/dsc sort_heap}}
{{dsc inc|cpp/algorithm/ranges/dsc sort_heap}}
{{dsc inc|cpp/algorithm/dsc is_heap}}
{{dsc inc|cpp/algorithm/ranges/dsc is_heap}}
{{dsc inc|cpp/algorithm/dsc is_heap_until}}
{{dsc inc|cpp/algorithm/ranges/dsc is_heap_until}}
{{dsc end}}

====Minimum/maximum operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc max}}
{{dsc inc|cpp/algorithm/ranges/dsc max}}
{{dsc inc|cpp/algorithm/dsc max_element}}
{{dsc inc|cpp/algorithm/ranges/dsc max_element}}
{{dsc inc|cpp/algorithm/dsc min}}
{{dsc inc|cpp/algorithm/ranges/dsc min}}
{{dsc inc|cpp/algorithm/dsc min_element}}
{{dsc inc|cpp/algorithm/ranges/dsc min_element}}
{{dsc inc|cpp/algorithm/dsc minmax}}
{{dsc inc|cpp/algorithm/ranges/dsc minmax}}
{{dsc inc|cpp/algorithm/dsc minmax_element}}
{{dsc inc|cpp/algorithm/ranges/dsc minmax_element}}
{{dsc inc|cpp/algorithm/dsc clamp}}
{{dsc inc|cpp/algorithm/ranges/dsc clamp}}
{{dsc end}}

====Lexicographical comparison operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc lexicographical_compare}}
{{dsc inc|cpp/algorithm/ranges/dsc lexicographical_compare}}
{{dsc inc|cpp/algorithm/dsc lexicographical_compare_three_way}}
{{dsc end}}

====Permutation operations====
{{dsc begin}}
{{dsc header|algorithm}}
{{dsc inc|cpp/algorithm/dsc next_permutation}}
{{dsc inc|cpp/algorithm/ranges/dsc next_permutation}}
{{dsc inc|cpp/algorithm/dsc prev_permutation}}
{{dsc inc|cpp/algorithm/ranges/dsc prev_permutation}}
{{dsc inc|cpp/algorithm/dsc is_permutation}}
{{dsc inc|cpp/algorithm/ranges/dsc is_permutation}}
{{dsc end}}

===Numeric operations===
{{dsc begin}}
{{dsc header|numeric}}
{{dsc inc|cpp/algorithm/dsc iota}}
{{dsc inc|cpp/algorithm/ranges/dsc iota}}
{{dsc inc|cpp/algorithm/dsc accumulate}}
{{dsc inc|cpp/algorithm/dsc inner_product}}
{{dsc inc|cpp/algorithm/dsc adjacent_difference}}
{{dsc inc|cpp/algorithm/dsc partial_sum}}
{{dsc inc|cpp/algorithm/dsc reduce}}
{{dsc inc|cpp/algorithm/dsc exclusive_scan}}
{{dsc inc|cpp/algorithm/dsc inclusive_scan}}
{{dsc inc|cpp/algorithm/dsc transform_reduce}}
{{dsc inc|cpp/algorithm/dsc transform_exclusive_scan}}
{{dsc inc|cpp/algorithm/dsc transform_inclusive_scan}}
{{dsc end}}

===Operations on uninitialized memory===
{{dsc begin}}
{{dsc header|memory}}
{{dsc inc|cpp/memory/dsc uninitialized_copy}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_copy}}
{{dsc inc|cpp/memory/dsc uninitialized_copy_n}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_copy_n}}
{{dsc inc|cpp/memory/dsc uninitialized_fill}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_fill}}
{{dsc inc|cpp/memory/dsc uninitialized_fill_n}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_fill_n}}
{{dsc inc|cpp/memory/dsc uninitialized_move}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_move}}
{{dsc inc|cpp/memory/dsc uninitialized_move_n}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_move_n}}
{{dsc inc|cpp/memory/dsc uninitialized_default_construct}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_default_construct}}
{{dsc inc|cpp/memory/dsc uninitialized_default_construct_n}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_default_construct_n}}
{{dsc inc|cpp/memory/dsc uninitialized_value_construct}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_value_construct}}
{{dsc inc|cpp/memory/dsc uninitialized_value_construct_n}}
{{dsc inc|cpp/memory/ranges/dsc uninitialized_value_construct_n}}
{{dsc inc|cpp/memory/dsc destroy}}
{{dsc inc|cpp/memory/ranges/dsc destroy}}
{{dsc inc|cpp/memory/dsc destroy_n}}
{{dsc inc|cpp/memory/ranges/dsc destroy_n}}
{{dsc inc|cpp/memory/dsc destroy_at}}
{{dsc inc|cpp/memory/ranges/dsc destroy_at}}
{{dsc inc|cpp/memory/dsc construct_at}}
{{dsc inc|cpp/memory/ranges/dsc construct_at}}
{{dsc end}}

{{anchor|Random number generation}}
===Random number generation {{mark since c++26}}===
{{dsc begin}}
{{dsc header|random}}
{{dsc inc|cpp/algorithm/ranges/dsc generate_random}}
{{dsc end}}

===Notes===
{{ftm begin|sort=yes}}
{{ftm|std=C++23|value=202207L|__cpp_lib_algorithm_iterator_requirements|Ranges iterators as inputs to non-Ranges algorithms}}
{{ftm|std=C++17|value=201603L|__cpp_lib_clamp|{{lc|std::clamp}}}}
{{ftm|std=C++20|value=201806L|__cpp_lib_constexpr_algorithms|rowspan="2"|Constexpr for algorithms}}
{{ftm|std=C++26|value=202306L|-|Constexpr stable sorting}}
{{ftm|std=C++26|value=202403L|__cpp_lib_algorithm_default_value_type|[[cpp/language/list initialization|List-initialization]] for algorithms}}
{{ftm|std=C++26|value=202311L|__cpp_lib_freestanding_algorithm|Freestanding facilities in {{header|algorithm}}}}
{{ftm|std=C++14|value=201304L|__cpp_lib_robust_nonmodifying_seq_ops|Making non-modifying sequence operations more robust (two-range overloads for {{lc|std::mismatch}}, {{lc|std::equal}} and {{lc|std::is_permutation)}}}}
{{ftm|std=C++17|value=201603L|__cpp_lib_sample|{{lc|std::sample}}}}
{{ftm|std=C++20|value=201806L|__cpp_lib_shift|{{lc|std::shift_left}} and {{lc|std::shift_right}}}}
{{ftm end}}

===C library===
{{dsc begin}}
{{dsc header|cstdlib}}
{{dsc inc|cpp/algorithm/dsc qsort}}
{{dsc inc|cpp/algorithm/dsc bsearch}}
{{dsc end}}

===Defect reports===
{{dr list begin}}
{{dr list item|wg=lwg|dr=193|std=C++98|before=heap required {{c|*first}} to be the largest element|after=there can be elements<br>equal to {{c|*first}}}}
{{dr list item|wg=lwg|dr=2150|std=C++98|before=the definition of a sorted sequence was incorrect|after=corrected}}
{{dr list item|wg=lwg|dr=2166|std=C++98|before=the heap requirement did not match the<br>definition of {{enwiki|Binary heap|max heap}} closely enough|after=requirement improved}}
{{dr list end}}

===See also===
{{dsc begin}}
{{dsc see c|c/algorithm|Algorithms|nomono=true}}
{{dsc end}}

{{langlinks|ar|de|es|fr|it|ja|pt|ru|tr|zh}}
Templates used on this page:
Return to cpp/algorithm.
cppreference.com

Search

Namespaces

Variants

Views

Actions

View source for cpp/algorithm

Navigation

Tools
