C++-Referenz/ Standardbibliothek/ Algorithmen

Aus Wikibooks
Zur Navigation springen Zur Suche springen
Symbol opinion vote.svg
Alte Seite

Die Arbeit am Buch »C++-Referenz« wurde vom Hauptautor eingestellt. Ein Lehrbuch zum Thema C++ ist unter »C++-Programmierung« zu finden. Eine sehr umfangreiche und gute Referenz gibt es unter cppreference.com.

Diese Seite beschreibt C++98, einen stark veralteten Standard. Aktuelle Referenz.

Nicht-Modifizierende sequenzoperationen[Bearbeiten]

for_each[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename Function>
Function for_each(InputIterator first, InputIterator last, Function f);

find[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename T>
InputIterator find(InputIterator first, InputIterator last, const T& value);

find_if[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename Predicate>
InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);

find_end[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator1, typename ForwardIterator2>
ForwardIterator1 find_end(
    ForwardIterator1 first1, ForwardIterator1 last1,
    ForwardIterator2 first2, ForwardIterator2 last2
);

template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
ForwardIterator1 find_end(
    ForwardIterator1 first1, ForwardIterator1 last1,
    ForwardIterator2 first2, ForwardIterator2 last2,
    BinaryPredicate pred
);

find_first_of[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator1, typename ForwardIterator2>
ForwardIterator1 find_first_of(
    ForwardIterator1 first1, ForwardIterator1 last1,
    ForwardIterator2 first2, ForwardIterator2 last2
);

template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
ForwardIterator1 find_first_of(
    ForwardIterator1 first1, ForwardIterator1 last1,
    ForwardIterator2 first2, ForwardIterator2 last2,
    BinaryPredicate pred
);

adjacent_find[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator>
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);

template<typename ForwardIterator, typename BinaryPredicate>
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);

count[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename T>
iterator_traits<InputIterator>::difference_type count(
    InputIterator first, InputIterator last, const T& value
);

count_if[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename Predicate>
iterator_traits<InputIterator>::difference_type count_if(
    InputIterator first, InputIterator last, Predicate pred
);

mismatch[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2>
pair<InputIterator1, InputIterator2> mismatch(
    InputIterator1 first1, InputIterator1 last1, InputIterator2 first2
);

template<typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
pair<InputIterator1, InputIterator2> mismatch(
    InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred
);

equal[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2>
bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

template<typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred);

search[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator1, typename ForwardIterator2>
ForwardIterator1 search(
    ForwardIterator1 first1, ForwardIterator1 last1,
    ForwardIterator2 first2, ForwardIterator2 last2
);

template<typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
ForwardIterator1 search(
    ForwardIterator1 first1, ForwardIterator1 last1,
    ForwardIterator2 first2, ForwardIterator2 last2,
    BinaryPredicate pred
);

search_n[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename Size, typename T>
ForwardIterator search_n(
    ForwardIterator first, ForwardIterator last, Size count, const T& value
);

template<typename ForwardIterator, typename Size, typename T, typename BinaryPredicate>
ForwardIterator search_n(
    ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate pred
);

Modifizierende sequenzoperationen[Bearbeiten]

Kopieren[Bearbeiten]

copy[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename OutputIterator>
OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);

copy_backward[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator1, typename BidirectionalIterator2>
BidirectionalIterator2 copy_backward(
    BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result
);

Vertauschen[Bearbeiten]

swap[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename T>
void swap(T& a, T& b);

swap_ranges[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator1, typename ForwardIterator2>
ForwardIterator2 swap_ranges(
    ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2
);

iter_swap[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator1, typename ForwardIterator2>
void iter_swap(ForwardIterator1 a, ForwardIterator2 b);

transform[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
OutputIterator transform(
    InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op
);

transform[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<
    typename InputIterator1, typename InputIterator2,
    typename OutputIterator,
    typename BinaryOperation
>
OutputIterator transform(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2,
    OutputIterator result,
    BinaryOperation binary_op
);

replace[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename T>
void replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);

replace_if[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename Predicate, typename T>
void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);

replace_copy[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename OutputIterator, typename T>
OutputIterator replace_copy(
    InputIterator first, InputIterator last,
    OutputIterator result,
    const T& old_value, const T& new_value
);

replace_copy_if[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename Iterator, typename OutputIterator, typename Predicate, typename T>
OutputIterator replace_copy_if(
    Iterator first, Iterator last,
    OutputIterator result,
    Predicate pred,
    const T& new_value
);

fill[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename T>
void fill(ForwardIterator first, ForwardIterator last, const T& value);

fill_n[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename OutputIterator, typename Size, typename T>
void fill_n(OutputIterator first, Size n, const T& value);

generate[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename Generator>
void generate(ForwardIterator first, ForwardIterator last, Generator gen);

generate_n[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename OutputIterator, typename Size, typename Generator>
void generate_n(OutputIterator first, Size n, Generator gen);

remove[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename T>
ForwardIterator remove(ForwardIterator first, ForwardIterator last, const T& value);

remove_if[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename Predicate>
ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);

remove_copy[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename OutputIterator, typename T>
OutputIterator remove_copy(
    InputIterator first, InputIterator last, OutputIterator result, const T& value
);

remove_copy_if[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename OutputIterator, typename Predicate>
OutputIterator remove_copy_if(
    InputIterator first, InputIterator last, OutputIterator result, Predicate pred
);

unique[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator>
ForwardIterator unique(ForwardIterator first, ForwardIterator last);

template<typename ForwardIterator, typename BinaryPredicate>
ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);

unique_copy[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename OutputIterator>
OutputIterator unique_copy(
    InputIterator first, InputIterator last, OutputIterator result
);

template<typename InputIterator, typename OutputIterator, typename BinaryPredicate>
OutputIterator unique_copy(
    InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred
);

reverse[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator>
void reverse(BidirectionalIterator first, BidirectionalIterator last);

reverse_copy[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator, typename OutputIterator>
OutputIterator reverse_copy(
    BidirectionalIterator first, BidirectionalIterator last, OutputIterator result
);

rotate[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator>
void rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);

rotate_copy[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename OutputIterator>
OutputIterator rotate_copy(
    ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result
);

random_shuffle[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void random_shuffle(
    RandomAccessIterator first, RandomAccessIterator last
);

template<typename RandomAccessIterator, typename RandomNumberGenerator>
void random_shuffle(
    RandomAccessIterator first, RandomAccessIterator last,
    RandomNumberGenerator& rand
);

Verteilen[Bearbeiten]

partition[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator, typename Predicate>
BidirectionalIterator partition(
    BidirectionalIterator first, BidirectionalIterator last, Predicate pred
);

stable_partition[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator, typename Predicate>
BidirectionalIterator stable_partition(
    BidirectionalIterator first, BidirectionalIterator last, Predicate pred
);

Sortier- und Zuordnungsoperationen[Bearbeiten]

Sortieren[Bearbeiten]

sort[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);

template<typename RandomAccessIterator, typename Compare>
void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

stable_sort[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);

template<typename RandomAccessIterator, typename Compare>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

partial_sort[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void partial_sort(
    RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last
);

template<typename RandomAccessIterator, typename Compare>
void partial_sort(
    RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last,
    Compare comp
);

partial_sort_copy[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator, typename RandomAccessIterator>
RandomAccessIterator partial_sort_copy(
    InputIterator first, InputIterator last,
    RandomAccessIterator result_first, RandomAccessIterator result_last
);

template<typename InputIterator, typename RandomAccessIterator, typename Compare>
RandomAccessIterator partial_sort_copy(
    InputIterator first, InputIterator last,
    RandomAccessIterator result_first, RandomAccessIterator result_last,
    Compare comp
);

nth_element[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void nth_element(
    RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last
);

template<typename RandomAccessIterator, typename Compare>
void nth_element(
    RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp
);

Binäre Suche[Bearbeiten]

lower_bound[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename T>
ForwardIterator lower_bound(
    ForwardIterator first, ForwardIterator last, const T& value
);

template<typename ForwardIterator, typename T, typename Compare>
ForwardIterator lower_bound(
    ForwardIterator first, ForwardIterator last, const T& value, Compare comp
);

upper_bound[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename T>
ForwardIterator upper_bound(
    ForwardIterator first, ForwardIterator last, const T& value
);

template<typename ForwardIterator, typename T, typename Compare>
ForwardIterator upper_bound(
    ForwardIterator first, ForwardIterator last, const T& value, Compare comp
);

equal_range[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename T>
pair<ForwardIterator, ForwardIterator> equal_range(
    ForwardIterator first, ForwardIterator last, const T& value
);

template<typename ForwardIterator, typename T, typename Compare>
pair<ForwardIterator, ForwardIterator> equal_range(
    ForwardIterator first, ForwardIterator last, const T& value, Compare comp
);

binary_search[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator, typename T>
bool binary_search(ForwardIterator first, ForwardIterator last, const T& value);

template<typename ForwardIterator, typename T, typename Compare>
bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

Verbinden[Bearbeiten]

merge[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
OutputIterator merge(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result
);

template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
OutputIterator merge(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result,
    Compare comp
);

inplace_merge[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator>
void inplace_merge(
    BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last
);

template<typename BidirectionalIterator, typename Compare>
void inplace_merge(
    BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last,
    Compare comp
);

Setzen[Bearbeiten]

includes[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2>
bool includes(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2
);

template<typename InputIterator1, typename InputIterator2, typename Compare>
bool includes(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    Compare comp
);

set_union[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
OutputIterator set_union(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result
);

template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
OutputIterator set_union(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result,
    Compare comp
);

set_intersection[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
OutputIterator set_intersection(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result
);

template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
OutputIterator set_intersection(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result,
    Compare comp
);

set_difference[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
OutputIterator set_difference(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result
);

template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
OutputIterator set_difference(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result,
    Compare comp
);

set_symmetric_difference[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
OutputIterator set_symmetric_difference(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result
);

template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Compare>
OutputIterator set_symmetric_difference(
    InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2,
    OutputIterator result,
    Compare comp
);

heap-Operationen[Bearbeiten]

push_heap[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void push_heap(RandomAccessIterator first, RandomAccessIterator last);

template<typename RandomAccessIterator, typename Compare>
void push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

pop_heap[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void pop_heap(RandomAccessIterator first, RandomAccessIterator last);

template<typename RandomAccessIterator, typename Compare>
void pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

make_heap[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void make_heap(RandomAccessIterator first, RandomAccessIterator last);

template<typename RandomAccessIterator, typename Compare>
void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

sort_heap[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename RandomAccessIterator>
void sort_heap(RandomAccessIterator first, RandomAccessIterator last);

template<typename RandomAccessIterator, typename Compare>
void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

Minimum und Maximum[Bearbeiten]

min[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename T>
const T& min(const T& a, const T& b);

template<typename T, typename Compare>
const T& min(const T& a, const T& b, Compare comp);

max[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename T>
const T& max(const T& a, const T& b);

template<typename T, typename Compare>
const T& max(const T& a, const T& b, Compare comp);

min_element[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator>
ForwardIterator min_element(ForwardIterator first,  ForwardIterator last);

template<typename ForwardIterator, typename Compare>
ForwardIterator min_element(ForwardIterator first,  ForwardIterator last, Compare comp);

max_element[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename ForwardIterator>
ForwardIterator max_element(ForwardIterator first,  ForwardIterator last);

template<typename ForwardIterator, typename Compare>
ForwardIterator max_element(ForwardIterator first,  ForwardIterator last, Compare comp);

lexicographical_compare[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename InputIterator1, typename InputIterator2>
bool lexicographical_compare(
    InputIterator1 first1, InputIterator1  last1,
    InputIterator2 first2, InputIterator2  last2
);

template<typename InputIterator1, typename InputIterator2, typename Compare>
bool lexicographical_compare(
    InputIterator1 first1, InputIterator1  last1,
    InputIterator2 first2, InputIterator2  last2,
    Compare comp
);

Permutationen[Bearbeiten]

next_permutation[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last);

template<typename BidirectionalIterator, typename Compare>
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);

prev_permutation[Bearbeiten]

Crystal Clear app terminal.png
// Header: algorithm
template<typename BidirectionalIterator>
bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last);

template<typename BidirectionalIterator, typename Compare>
bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);