名前空間
変種
操作

標準ライブラリヘッダ <algorithm>

提供: cppreference.com
< cpp‎ | header
 
 
 

このヘッダはアルゴリズムライブラリの一部です。

目次

[編集] 関数

非変更シーケンス操作
(C++11)(C++11)(C++11)
述語が指定範囲の要素のすべてに対して true を返すかどうか、いずれかに対して true を返すかどうか、またはいずれに対しても true を返さないかどうか、調べます
(関数テンプレート) [edit]
指定範囲の要素に関数を適用します
(関数テンプレート) [edit]
指定個数の要素に関数を適用します
(関数テンプレート) [edit]
一定の基準を満たす要素の数を返します
(関数テンプレート) [edit]
2つの範囲が異なる最初の位置を探します
(関数テンプレート) [edit]
一定の基準を満たす最初の要素を探します
(関数テンプレート) [edit]
指定された要素の並びが現れる最後の位置を探します
(関数テンプレート) [edit]
指定された要素のいずれかが現れる位置を探します
(関数テンプレート) [edit]
同じ要素 (または指定された述語を満たす要素) 2つが隣接している最初の位置を探します
(関数テンプレート) [edit]
指定範囲の要素に対して検索を行います
(関数テンプレート) [edit]
指定個数の連続する指定要素を指定範囲から検索します
(関数テンプレート) [edit]
変更シーケンス操作
指定範囲の要素を新しい位置にコピーします
(関数テンプレート) [edit]
(C++11)
指定個数の要素を新しい位置にコピーします
(関数テンプレート) [edit]
指定範囲の要素を後ろからコピーします
(関数テンプレート) [edit]
(C++11)
指定範囲の要素を新しい位置にムーブします
(関数テンプレート) [edit]
指定範囲の要素を後ろからムーブします
(関数テンプレート) [edit]
指定された要素を範囲内の全要素にコピー代入します
(関数テンプレート) [edit]
指定された要素を指定個数の要素にコピー代入します
(関数テンプレート) [edit]
指定範囲の要素に関数を適用します
(関数テンプレート) [edit]
関数を連続的に呼び出した結果を指定範囲の全要素に代入します
(関数テンプレート) [edit]
関数を連続的に呼び出した結果を指定個数の要素に代入します
(関数テンプレート) [edit]
一定の基準を満たす要素を削除します
(関数テンプレート) [edit]
指定範囲の要素から一定の基準を満たすものを除いてコピーします
(関数テンプレート) [edit]
一定の基準を満たすすべての値を別の値に置き換えます
(関数テンプレート) [edit]
一定の基準を満たす要素を別の値に置き換えながら指定範囲をコピーします
(関数テンプレート) [edit]
2つのオブジェクトの値を入れ替えます
(関数テンプレート) [edit]
2つの範囲の要素を入れ替えます
(関数テンプレート) [edit]
2つのイテレータが指す要素を入れ替えます
(関数テンプレート) [edit]
指定範囲の要素の順序を反転させます
(関数テンプレート) [edit]
指定範囲の要素の順序を反転させたコピーを作成します
(関数テンプレート) [edit]
指定範囲の要素の順序を回転させます
(関数テンプレート) [edit]
指定範囲の要素の順序を回転させたコピーを作成します
(関数テンプレート) [edit]
範囲内の要素をシフトします
(関数テンプレート) [edit]
(C++17未満)(C++11)
指定範囲の要素をランダムに並べ替えます
(関数テンプレート) [edit]
(C++17)
指定個数の要素をランダムに選択します
(関数テンプレート) [edit]
指定範囲の連続している重複要素を削除します
(関数テンプレート) [edit]
指定範囲の要素の連続している重複要素が含まれないコピーを作成します
(関数テンプレート) [edit]
分割操作
指定範囲が指定した述語で分割されているかどうか調べます
(関数テンプレート) [edit]
指定範囲の要素を2つのグループに分割します
(関数テンプレート) [edit]
指定範囲の要素を2つのグループに分割しながらコピーします
(関数テンプレート) [edit]
相対的な順序を維持しながら要素を2つのグループに分割します
(関数テンプレート) [edit]
分割された範囲の分割点を探します
(関数テンプレート) [edit]
ソート操作
(C++11)
指定範囲が昇順にソートされているか調べます
(関数テンプレート) [edit]
最も大きなソート済みの部分範囲を探します
(関数テンプレート) [edit]
指定範囲を昇順にソートします
(関数テンプレート) [edit]
指定範囲の最初の N 個の要素をソートします
(関数テンプレート) [edit]
指定範囲の最初の N 個の要素がソートされたコピーを作成します
(関数テンプレート) [edit]
等しい要素間の順序を維持しながら指定範囲の要素をソートします
(関数テンプレート) [edit]
指定された要素で分割されるように指定範囲を部分ソートします
(関数テンプレート) [edit]
二分探索操作 (ソート済み範囲用)
指定された値より小さくない最初の要素を指すイテレータを返します
(関数テンプレート) [edit]
指定された値より大きい最初の要素へのイテレータを返します
(関数テンプレート) [edit]
指定範囲に要素が存在するかどうか調べます
(関数テンプレート) [edit]
特定のキーに一致する要素の範囲を返します
(関数テンプレート) [edit]
ソート済み範囲に対するその他の操作
2つのソート済み範囲をマージします
(関数テンプレート) [edit]
2つのソート済み範囲をその場でマージします
(関数テンプレート) [edit]
集合演算 (ソート済み範囲用)
ある集合が別の集合の部分集合であるかどうか調べます
(関数テンプレート) [edit]
2つの集合の差を計算します
(関数テンプレート) [edit]
2つの集合の交叉を計算します
(関数テンプレート) [edit]
2つの集合の対称差を計算します
(関数テンプレート) [edit]
2つの集合の和を計算します
(関数テンプレート) [edit]
ヒープ操作
(C++11)
指定範囲が最大ヒープであるかどうか調べます
(関数テンプレート) [edit]
最大ヒープである最も大きな部分範囲を探します
(関数テンプレート) [edit]
指定範囲の要素から最大ヒープを作成します
(関数テンプレート) [edit]
最大ヒープに要素を追加します
(関数テンプレート) [edit]
最大ヒープから最も大きな要素を削除します
(関数テンプレート) [edit]
最大ヒープを昇順にソートされた要素の範囲に変換します
(関数テンプレート) [edit]
最大/最小演算
指定された値の大きい方を返します
(関数テンプレート) [edit]
指定範囲の最も大きな要素を返します
(関数テンプレート) [edit]
指定された値の小さい方を返します
(関数テンプレート) [edit]
指定範囲の最も小さな要素を返します
(関数テンプレート) [edit]
(C++11)
2つの要素の小さい方と大きい方を返します
(関数テンプレート) [edit]
指定範囲の最も小さな要素と最も大きな要素を返します
(関数テンプレート) [edit]
(C++17)
値を境界値の間にクランプします
(関数テンプレート) [edit]
比較演算
2つの要素集合が同じかどうか調べます
(関数テンプレート) [edit]
ある範囲が別の範囲より辞書的に小さいかどうか調べます
(関数テンプレート) [edit]
三方比較を使用して2つの値を比較します
(関数テンプレート) [edit]
三方比較を使用して2つの範囲を比較します
(関数テンプレート) [edit]
順列操作
あるシーケンスが別のシーケンスの順列並び替えになっているかどうか調べます
(関数テンプレート) [edit]
指定範囲の要素より辞書的に大きな次の順列を生成します
(関数テンプレート) [edit]
指定範囲の要素より辞書的に小さな次の順列を生成します
(関数テンプレート) [edit]

[編集] 概要

#include <initializer_list>
namespace std
{
    // non-modifying sequence operations:
    template <class InputIterator, class Predicate>
        bool all_of(InputIterator first, InputIterator last, Predicate pred);
    template <class InputIterator, class Predicate>
        bool any_of(InputIterator first, InputIterator last, Predicate pred);
    template <class InputIterator, class Predicate>
        bool none_of(InputIterator first, InputIterator last, Predicate pred);
 
    template<class InputIterator, class Function>
        Function for_each(InputIterator first, InputIterator last, Function f);
 
    template<class InputIterator, class Size, class UnaryFunction>
        InputIterator for_each_n(InputIterator first, Size n, UnaryFunction f);
 
    template<class InputIterator, class T>
        InputIterator find(InputIterator first, InputIterator last,
                           const T& value);
    template<class InputIterator, class Predicate>
        InputIterator find_if(InputIterator first, InputIterator last,
                              Predicate pred);
    template<class InputIterator, class Predicate>
        InputIterator find_if_not(InputIterator first, InputIterator last,
                                  Predicate pred);
 
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2);
    template<class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate>
        ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 BinaryPredicate pred);
 
    template<class InputIterator, class ForwardIterator>
        InputIterator
        find_first_of(InputIterator first1, InputIterator last1,
                      ForwardIterator first2, ForwardIterator last2);
    template<class InputIterator, class ForwardIterator,
             class BinaryPredicate>
        InputIterator
        find_first_of(InputIterator first1, InputIterator last1,
                      ForwardIterator first2, ForwardIterator last2,
                      BinaryPredicate pred);
 
    template<class ForwardIterator>
        ForwardIterator adjacent_find(ForwardIterator first,
                                      ForwardIterator last);
    template<class ForwardIterator, class BinaryPredicate>
        ForwardIterator adjacent_find(ForwardIterator first,
                                      ForwardIterator last,
                                      BinaryPredicate pred);
    template<class InputIterator, class T>
        typename iterator_traits<InputIterator>::difference_type
        count(InputIterator first, InputIterator last, const T& value);
    template<class InputIterator, class Predicate>
        typename iterator_traits<InputIterator>::difference_type
        count_if(InputIterator first, InputIterator last, Predicate pred);
 
    template<class InputIterator1, class InputIterator2>
        pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2);
    template<class InputIterator1, class InputIterator2, class BinaryPredicate>
        pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, BinaryPredicate pred);
 
    template<class InputIterator1, class InputIterator2>
        bool equal(InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2);
    template<class InputIterator1, class InputIterator2, class BinaryPredicate>
        bool equal(InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, BinaryPredicate pred);
 
    template<class ForwardIterator1, class ForwardIterator2>
        bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2);
    template<class ForwardIterator1, class ForwardIterator2,
    class BinaryPredicate>
        bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, BinaryPredicate pred);
 
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1 search(
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2);
    template<class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate>
        ForwardIterator1 search(
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 
    template<class ForwardIterator, class Size, class T>
        ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                                 Size count, const T& value);
    template<class ForwardIterator, class Size, class T, class BinaryPredicate>
        ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                                  Size count, const T& value,
                                  BinaryPredicate pred);
 
    // modifying sequence operations:
 
    // copy:
    template<class InputIterator, class OutputIterator>
        OutputIterator copy(InputIterator first, InputIterator last,
                            OutputIterator result);
    template<class InputIterator, class Size, class OutputIterator>
        OutputIterator copy_n(InputIterator first, Size n,
                              OutputIterator result);
    template<class InputIterator, class OutputIterator, class Predicate>
        OutputIterator copy_if(InputIterator first, InputIterator last,
                               OutputIterator result, Predicate pred);
    template<class BidirectionalIterator1, class BidirectionalIterator2>
        BidirectionalIterator2 copy_backward(
            BidirectionalIterator1 first, BidirectionalIterator1 last,
            BidirectionalIterator2 result);
 
    // move:
    template<class InputIterator, class OutputIterator>
        OutputIterator move(InputIterator first, InputIterator last,
                            OutputIterator result);
    template<class BidirectionalIterator1, class BidirectionalIterator2>
        BidirectionalIterator2 move_backward(
            BidirectionalIterator1 first, BidirectionalIterator1 last,
            BidirectionalIterator2 result);
 
    // swap:
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator2 swap_ranges(ForwardIterator1 first1,
                                     ForwardIterator1 last1, ForwardIterator2 first2);
    template<class ForwardIterator1, class ForwardIterator2>
        void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
    template<class InputIterator, class OutputIterator, class UnaryOperation>
        OutputIterator transform(InputIterator first, InputIterator last,
                                 OutputIterator result, UnaryOperation op);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class BinaryOperation>
        OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, OutputIterator result,
                                 BinaryOperation binary_op);
 
    template<class ForwardIterator, class T>
        void replace(ForwardIterator first, ForwardIterator last,
                     const T& old_value, const T& new_value);
    template<class ForwardIterator, class Predicate, class T>
        void replace_if(ForwardIterator first, ForwardIterator last,
                        Predicate pred, const T& new_value);
    template<class InputIterator, class OutputIterator, class T>
        OutputIterator replace_copy(InputIterator first, InputIterator last,
                                    OutputIterator result,
                                    const T& old_value, const T& new_value);
    template<class InputIterator, class OutputIterator, class Predicate, class T>
        OutputIterator replace_copy_if(InputIterator first, InputIterator last,
                                       OutputIterator result,
                                       Predicate pred, const T& new_value);
 
    template<class ForwardIterator, class T>
        void fill(ForwardIterator first, ForwardIterator last, const T& value);
    template<class OutputIterator, class Size, class T>
        OutputIterator fill_n(OutputIterator first, Size n, const T& value);
    template<class ForwardIterator, class Generator>
        void generate(ForwardIterator first, ForwardIterator last,
                      Generator gen);
    template<class OutputIterator, class Size, class Generator>
        OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
 
    template<class ForwardIterator, class T>
        ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                               const T& value);
    template<class ForwardIterator, class Predicate>
        ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                  Predicate pred);
    template<class InputIterator, class OutputIterator, class T>
        OutputIterator remove_copy(InputIterator first, InputIterator last,
                                   OutputIterator result, const T& value);
    template<class InputIterator, class OutputIterator, class Predicate>
        OutputIterator remove_copy_if(InputIterator first, InputIterator last,
                                      OutputIterator result, Predicate pred);
 
    template<class ForwardIterator>
        ForwardIterator unique(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class BinaryPredicate>
        ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                               BinaryPredicate pred);
    template<class InputIterator, class OutputIterator>
        OutputIterator unique_copy(InputIterator first, InputIterator last,
                                   OutputIterator result);
    template<class InputIterator, class OutputIterator, class BinaryPredicate>
        OutputIterator unique_copy(InputIterator first, InputIterator last,
                                   OutputIterator result, BinaryPredicate pred);
 
    template<class BidirectionalIterator>
        void reverse(BidirectionalIterator first, BidirectionalIterator last);
    template<class BidirectionalIterator, class OutputIterator>
        OutputIterator reverse_copy(BidirectionalIterator first,
                                    BidirectionalIterator last,
                                    OutputIterator result);
 
    template<class ForwardIterator>
        ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
                               ForwardIterator last);
    template<class ForwardIterator, class OutputIterator>
        OutputIterator rotate_copy(
            ForwardIterator first, ForwardIterator middle,
            ForwardIterator last, OutputIterator result);
 
    template<class RandomAccessIterator>
        void random_shuffle(RandomAccessIterator first,
                            RandomAccessIterator last);
    template<class RandomAccessIterator, class RandomNumberGenerator>
        void random_shuffle(RandomAccessIterator first,
                            RandomAccessIterator last,
                            RandomNumberGenerator&& rand);
    template<class RandomAccessIterator, class UniformRandomNumberGenerator>
        void shuffle(RandomAccessIterator first,
                     RandomAccessIterator last,
                     UniformRandomNumberGenerator&& rand);
 
    // partitions:
    template <class InputIterator, class Predicate>
        bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
 
    template<class ForwardIterator, class Predicate>
        ForwardIterator partition(ForwardIterator first,
                                  ForwardIterator last,
                                  Predicate pred);
 
    template<class BidirectionalIterator, class Predicate>
        BidirectionalIterator stable_partition(BidirectionalIterator first,
                                               BidirectionalIterator last,
                                               Predicate pred);
 
    template <class InputIterator, class OutputIterator1,
              class OutputIterator2, class Predicate>
        pair<OutputIterator1, OutputIterator2>
        partition_copy(InputIterator first, InputIterator last,
                       OutputIterator1 out_true, OutputIterator2 out_false,
                       Predicate pred);
 
    template<class ForwardIterator, class Predicate>
        ForwardIterator partition_point(ForwardIterator first,
                                        ForwardIterator last,
                                        Predicate pred);
 
    // sorting and related operations:
 
    // sorting:
    template<class RandomAccessIterator>
        void sort(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void sort(RandomAccessIterator first, RandomAccessIterator last,
                  Compare comp);
 
    template<class RandomAccessIterator>
        void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
 
    template<class RandomAccessIterator>
        void partial_sort(RandomAccessIterator first,
                          RandomAccessIterator middle,
                          RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void partial_sort(RandomAccessIterator first,
                          RandomAccessIterator middle,
                          RandomAccessIterator last, Compare comp);
    template<class InputIterator, class RandomAccessIterator>
        RandomAccessIterator partial_sort_copy(
            InputIterator first, InputIterator last,
            RandomAccessIterator result_first,
            RandomAccessIterator result_last);
    template<class InputIterator, class RandomAccessIterator, class Compare>
        RandomAccessIterator partial_sort_copy(
            InputIterator first, InputIterator last,
            RandomAccessIterator result_first,
            RandomAccessIterator result_last,
            Compare comp);
 
    template<class ForwardIterator>
        bool is_sorted(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        bool is_sorted(ForwardIterator first, ForwardIterator last,
                       Compare comp);
    template<class ForwardIterator>
        ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last,
                                        Compare comp);
 
    template<class RandomAccessIterator>
        void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                         RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                         RandomAccessIterator last, Compare comp);
    // binary search:
    template<class ForwardIterator, class T>
        ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value);
    template<class ForwardIterator, class T, class Compare>
        ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value, Compare comp);
 
    template<class ForwardIterator, class T>
        ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value);
    template<class ForwardIterator, class T, class Compare>
        ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value, Compare comp);
 
    template<class ForwardIterator, class T>
        pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T& value);
    template<class ForwardIterator, class T, class Compare>
        pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T& value, Compare comp);
 
    template<class ForwardIterator, class T>
        bool binary_search(ForwardIterator first, ForwardIterator last,
                           const T& value);
    template<class ForwardIterator, class T, class Compare>
        bool binary_search(ForwardIterator first, ForwardIterator last,
                           const T& value, Compare comp);
 
    // merge:
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
            class Compare>
        OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             OutputIterator result, Compare comp);
 
    template<class BidirectionalIterator>
        void inplace_merge(BidirectionalIterator first,
                           BidirectionalIterator middle,
                           BidirectionalIterator last);
    template<class BidirectionalIterator, class Compare>
        void inplace_merge(BidirectionalIterator first,
                           BidirectionalIterator middle,
                           BidirectionalIterator last, Compare comp);
 
    // set operations:
    template<class InputIterator1, class InputIterator2>
        bool includes(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, InputIterator2 last2);
    template<class InputIterator1, class InputIterator2, class Compare>
        bool includes(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_intersection(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_intersection(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_symmetric_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_symmetric_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
 
    // heap operations:
    template<class RandomAccessIterator>
        void push_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void push_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
    template<class RandomAccessIterator>
        void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                      Compare comp);
 
    template<class RandomAccessIterator>
        void make_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void make_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
 
    template<class RandomAccessIterator>
        void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
 
    template<class RandomAccessIterator>
        bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        bool is_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
    template<class RandomAccessIterator>
        RandomAccessIterator 
            is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        RandomAccessIterator 
            is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
                                           Compare comp);
    // minimum and maximum:
    template<class T> const T& min(const T& a, const T& b);
    template<class T, class Compare>
        const T& min(const T& a, const T& b, Compare comp);
    template<class T>
        T min(initializer_list<T> t);
    template<class T, class Compare>
        T min(initializer_list<T> t, Compare comp);
 
    template<class T> const T& max(const T& a, const T& b);
    template<class T, class Compare>
        const T& max(const T& a, const T& b, Compare comp);
    template<class T>
        T max(initializer_list<T> t);
    template<class T, class Compare>
        T max(initializer_list<T> t, Compare comp);
 
    template<class T> pair<const T&, const T&> minmax(const T& a, const T& b);
    template<class T, class Compare>
        pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
    template<class T>
        pair<T, T> minmax(initializer_list<T> t);
    template<class T, class Compare>
        pair<T, T> minmax(initializer_list<T> t, Compare comp);
 
    template<class ForwardIterator>
        ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                    Compare comp);
 
    template<class ForwardIterator>
        ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                    Compare comp);
 
    template<class ForwardIterator>
        pair<ForwardIterator, ForwardIterator>
        minmax_element(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        pair<ForwardIterator, ForwardIterator>
        minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
 
    template<class InputIterator1, class InputIterator2>
        bool lexicographical_compare(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2);
    template<class InputIterator1, class InputIterator2, class Compare>
        bool lexicographical_compare(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            Compare comp);
 
    // permutations:
    template<class BidirectionalIterator>
        bool next_permutation(BidirectionalIterator first,
                              BidirectionalIterator last);
    template<class BidirectionalIterator, class Compare>
        bool next_permutation(BidirectionalIterator first,
                              BidirectionalIterator last, Compare comp);
 
    template<class BidirectionalIterator>
        bool prev_permutation(BidirectionalIterator first,
                              BidirectionalIterator last);
    template<class BidirectionalIterator, class Compare>
        bool prev_permutation(BidirectionalIterator first,
                              BidirectionalIterator last, Compare comp);
}