Algorithmen

#include <algorithm>

non-mutating algorithms

UnaryFunction for_each (InputIterator first, InputIterator last, UnaryFunction f);
bool all_of (Iterator first, Iterator last, Predicate pred);
bool any_of (Iterator first, Iterator last, Predicate pred);
bool none_of (Iterator first, Iterator last, Predicate pred);
InputIterator find (InputIterator first, InputIterator last, const EqualityComparable & value);
InputIterator find_if (InputIterator first, InputIterator last, Predicate pred);
Iterator find_if_not (Iterator first, Iterator last, Predicate pred);
ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last);
ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
InputIterator find_first_of (InputIterator first1, InputIterator last1,
ForwardIterator first2, ForwardIterator last2, Compare comp = 0);
difference_type count (InputIterator first, InputIterator last, const EqualityComparable & value);
void count (InputIterator first, InputIterator last, const EqualityComparable & value,
Size & n);
difference_type count_if (InputIterator first, InputIterator last, Predicate pred);
void count_if (InputIterator first, InputIterator last, Predicate pred,
Size & n);
pair<Inp2, Inp2> mismatch (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred = 0);
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
BinaryPredicate pred = 0);
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred = 0);
ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Integer count,
const T & value,
BinaryPredicate pred = 0);
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2, Compare comp = 0);

mutating algorithms

OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);
OutputIterator copy_n (InputIterator first, Size count, OutputIterator result);
BidirectionalI copy_backward (BidirectionalI1 first, BidirectionalI1 last, BidirectionalI2 result);
void swap (Assignable & a, Assignable & b);
void iter_swap (ForwardIterator1 a, ForwardIterator2 b);
ForwardIterator swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
OutputIterator transform (InputIterator first, InputIterator last, OutputIterator result,
UnaryFunction op);
OutputIterator transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
OutputIterator result,
BinaryFunction op);
void replace (ForwardIterator first, ForwardIterator last, const T & old_value,
const T & new_value);
void replace_if (ForwardIterator first, ForwardIterator last, Predicate pred,
const T & new_value);
OutputIterator replace_copy (InputIterator first, InputIterator last, OutputIterator result,
const T & old_value,
const T & new_value);
OutputIterator replace_copy_if (InputIterator first, InputIterator last, OutputIterator result,
Predicate pred,
const T & new_value);
void fill (ForwardIterator first, ForwardIterator last, const T & value);
void generate (ForwardIterator first, ForwardIterator last, Generator gen);
OutputIterator fill_n (OutputIterator first, Size n, const T & value);
OutputIterator generate_n (OutputIterator first, Size n, Generator gen);
ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T & value);
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, Predicate pred);
OutputIterator remove_copy (InputIterator first, InputIterator last, OutputIterator result,
const T & value);
OutputIterator remove_copy_if (InputIterator first, InputIterator last, OutputIterator result,
Predicate pred);
ForwardIterator unique (ForwardIterator first, ForwardIterator last, BinaryPredicate pred = 0);
OutputIterator unique_copy (InputIterator first, InputIterator last, OutputIterator result,
BinaryPredicate pred = 0);
ForwardIterator rotate (ForwardIterator first, ForwardIterator middle, ForwardIterator last);
OutputIterator rotate_copy (ForwardIterator first, ForwardIterator middle, ForwardIterator last,
OutputIterator result);
void reverse (BidirectionalI first, BidirectionalI last);
OutputIterator reverse_copy (BidirectionalI first, BidirectionalI last, OutputIterator result);
void random_shuffle (RandomAccessI first, RandomAccessI last, RandomNumberGenerator & rng = 0);
RandomAccessI random_sample (InputIterator first1, InputIterator last1,
RandomAccessI first2, RandomAccessI last2, RandomNumberGenerator & rng = 0);
OutputIterator random_sample_n (ForwardIterator first, ForwardIterator last, OutputIterator result,
Distance n,
RandomNumberGenerator & rng = 0);
ForwardIterator partition (ForwardIterator first, ForwardIterator last, Predicate pred)
ForwardIterator stable_partition (ForwardIterator first, ForwardIterator last, Predicate pred);

sorting, searching & merging

void sort (RandomAccessI first, RandomAccessI last,
Compare comp = 0);
void stable_sort (RandomAccessI first, RandomAccessI last,
Compare comp = 0);
void partial_sort (RandomAccessI first, RandomAccessI middle, RandomAccessI last,
Compare comp = 0);
RandomAccessI partial_sort_copy (InputIterator first, InputIterator last,
RandomAccessI first, RandomAccessI last, Compare comp = 0);
pair<Out, Out> partition_copy (InputIterator first, InputIterator last,
OutputIterator1 out_true, OutputIterator2 out_false,
Predicate pred);
Iterator partition_point (Iterator first, Iterator last, Predicate pred);
bool is_sorted (ForwardIterator first, ForwardIterator last,
Compare comp = 0);
Iterator is_sorted_until (Iterator first, Iterator last, Compare comp);
void nth_element (RandomAccessI first, RandomAccessI nth, RandomAccessI last,
Compare comp = 0);
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const LessThanComparable & value);
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T & value,
Compare comp);
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const LessThanComparable & value);
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T & value,
Compare comp);
pair<Fwd, Fwd> equal_range (ForwardIterator first, ForwardIterator last, const LessThanComparable & value);
pair<Fwd, Fwd> equal_range (ForwardIterator first, ForwardIterator last, const T & value,
Compare comp);
bool binary_search (ForwardIterator first, ForwardIterator last, const LessThanComparable & value);
bool binary_search (ForwardIterator first, ForwardIterator last, const T & value,
Compare comp);
OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result,
Compare comp = 0);
void inplace_merge (BidirectionalI first, BidirectionalI middle, BidirectionalI last,
Compare comp = 0);

set operations on sorted ranges

bool includes (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, Compare comp = 0);
OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result,
Compare comp = 0);
OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result,
Compare comp = 0);
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result,
Compare comp = 0);
OutputIterator set_symmetric
_difference		(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result,
Compare comp = 0);

heap operations

void push_heap (RandomAccessI first, RandomAccessI last, Compare comp = 0);
void pop_heap (RandomAccessI first, RandomAccessI last, Compare comp = 0);
void make_heap (RandomAccessI first, RandomAccessI last, Compare comp = 0);
void sort_heap (RandomAccessI first, RandomAccessI last, Compare comp = 0);
bool is_heap (Iterator first, Iterator last, Compare comp = 0);
Iterator is_heap_until (Iterator first, Iterator last, Compare comp = 0);

minimum and maximum

const T & min (const T & a, const T & b, Compare comp = 0);
const T & max (const T & a, const T & b, Compare comp = 0);
T min (initializer_list<T> t);
T min (initializer_list<T> t, Compare comp);
T max (initializer_list<T> t);
T max (initializer_list<T> t, Compare comp);
pair<T&,T&> minmax (const T & a, const T & b);
pair<T&,T&> minmax (const T & a, const T & b, Compare comp);
pair<T&,T&> minmax (initializer_list<T> t);
pair<T&,T&> minmax (initializer_list<T> t, Compare comp);
ForwardIterator min_element (ForwardIterator first, ForwardIterator last, Compare comp = 0);
ForwardIterator max_element (ForwardIterator first, ForwardIterator last, Compare comp = 0);
pair<I,I> minmax_element (Iterator first, Iterator last);
pair<I,I> minmax_element (Iterator first, Iterator last, Compare comp);
bool lexicographical
_compare		(InputIterator1 first1, InputIterator1 last1,
(InputIterator2 first2, InputIterator2 last2, Compare comp = 0);
int lexicographical
_compare_3way		(InputIterator1 first1,InputIterator1 last1,
(InputIterator2 first2, InputIterator2 last2);
bool next_permutation (BidirectionalI first, BidirectionalI last, Compare comp = 0);
bool prev_permutation (BidirectionalI first, BidirectionalI last, Compare comp = 0);

Numerische Algorithmen

#include <numeric>
void iota (ForwardIterator first, ForwardIterator last, T value);
T accumulate (InputIterator first, InputIterator last, T init,
BinaryFunction op = 0);
T inner_product (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, T init, BinaryFunction1 op1 = 0,
BinaryFunction2 op2 = 0);
OutputIterator partial_sum (InputIterator first, InputIterator last, OutputIterator result,
BinaryFunction op = 0);
OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result,
BinaryFunction op = 0);
T power (T x, Integer n);
T power (T x, Integer n, MonoidOperation op);