#include <algorithm>
algorithm头文件中主要包含的是一大堆模板函数，即STL库提供的算法，可以认为每个函数在很大程度上是独立的。提供的算法种类有：
1）adjacent_find //检测区间内第一对相等的相邻元素
template<class FwIt>
FwIt adjacent_find(FwdIt first,FwdIt last); //如果成功，返回first+N，N满足*(first+N) == *(first+N+1)；如果不存在相等的相邻元素，返回last
template<class FwIt,calss Pred>
FwIt adjacent_find(FwIt first,FwIt last,Pred pr); //用户可自定义条件或函数，只要满足pr(*(first+N),*(first+N+1))，就返回first+N；没有不满足条件，返回last
2）binary_search //测试在有序区间是否存在某个值，返回bool
template<class FwIt,class T>
bool binary_search(FwIt first,FwIt last,const T& val); //查找val是否在区间[first,last)存在，存在返回true，不存在返回false
template<class FwIt,class T,class Pred>
bool binary_search(FwIt first,FwIt last,const T& val,Pred pr);
3）copy //将一个序列从头至尾的复制到另一个序列
template<class InIt,class OutIt>
Outlt copy(InIt first,InIt last,OutIt x); //将区间[first,last)内的元素复制到目标区间[x,x+(last-first))中
4）copy_backward //将一个序列从尾至头的复制到另一个序列
template<class BidIt1,class BidIt2>
BidIt2 copy_backward(BidIt1 first,BidIt1 last,BidIt2 x); //将区间[first,last)复制到区间[x-(last-first),x)间，复制顺序为：先复制last-1迭代器指向的元素到x-1中，直到first指向元素复制到x-(last-first)中
5）count //计算在序列中等于一个指定值的元素的个数
template<class InIt,class T>
typename iterator_traits<InIt>::difference_type count(InIt first,InIt last,const T& val); //注意返回类型
6）count_if //要计算在序列中使得函数对象pr(*(first+N))返回true的元素的个数
template<class InIt,class Pred>
typename iterator_traits<InIt>::difference_type count_if(InIt first,InIt last,Pred pr);
7）equal //比较两个序列是否相等
template<class InIt1,class InIt2>
bool equal(InIt1 first1,InIt1 last1,InIt2 first2); //判断区间[first1,last1)与区间[first2,first2+(last1-first1))是否相等
template<class InIt1,class InIt2,class Pred>
bool equal(InIt1 first1,InIt1 last1,InIt2 first2,Pred pr);
8）lower_bound //返回一个非递减序列[first, last)中的第一个大于等于值val的位置
template<class FwdIt,class T>
FwdIt lower_bound(FwdIt first,FwdIt last,const T& val);
template<class FwdIt,class T,class Pred>
FwdIt lower_bound(FwdIt first,FwdIt last,const T& val,Pred pr);
9）upper_bound //返回一个非递减序列[first, last)中的第一个大于值val的位置
template<class FwdIt,class T>
FwdIt upper_bound(FwdIt first,FwdIt last,const T& val);
template<class FwdIt,class T,class Pred>
FwdIt upper_bound(FwdIt first,FwdIt last,const T& val,Pred pr);
10）equal_range //在已排序的[first,last)中寻找val，它返回一对迭代器i和j，其中i是在不破坏次序的前提下，val可插入的第一个位置（亦即lower_bound），j则是在不破坏次序的前提下，val可插入的最后一个位置（亦即upper_bound）
template<class FwdIt,class T>
pair<FwdIt,FwdIt> equal_range(FwdIt first,FwdIt last,const T& val);
template<class FwdIt,class T,class Pred>
pair<FwdIt,FwdIt> equal_range(FwdIt first,FwdIt last,const T& val,Pred pr);
11）fill //将一个特定的值赋给序列中的每一个元素
template<class FwdIt,class T>
void fill(FwdIt first,FwdIt last,const T& val);
12）fill_n //将一个特定的值赋给序列中的前n个元素
template<class OutIt,class Size,class T>
void fill_n(OutIt first,Size n,const T& val);
13）find //检测序列中第一个等于指定值的元素
template<class InIt,class T>
InIt find(InIt first,InIt last,const T& val);
14）find_end //在一个序列中搜索出最后一个与另一序列匹配的子序列
template<class FwdIt1,class FwdIt2>
FwdIt1 find_end(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2);
template<class FwdIt1,class FwdIt2,class Pred>
FwdIt1 find_end(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2,Pred pr);
15）find_first_of //要在序列中检测另一个序列中任意元素第一次出现的地方
template<class FwdIt1,class FwdIt2>
FwdIt1 find_first_of(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2);
template<class FwdIt1,class FwdIt2,class Pred>
FwdIt1 find_first_of(FwdIt1 first1,FwdIt1 last1,FwdIt2 first2,FwdIt2 last2,Pred pr);
16）find_if //检测序列中第一个使得pr(*(first+N))==true出现的元素
template<class InIt,class Pred>
InIt find_if(InIt first,InIt last,Pred pr);
17）for_each //对序列中的每个元素，都调用函数对象f，执行f(*(first+N))
template<class InIt,class Fun>
Fun for_each(InIt first,InIt last,Fun f);
18）generate //要使用函数对象g，对序列中的每个元素都赋值为g()
template<class FwdIt,class Gen>
void generate(FwdIt first,FwdIt last,Gen g);
19）generate_n //要使用函数对象g，对序列中的前n个元素赋值为g()
template<class OutIt,class Size,class Gen>
void generate_n(OutIt first,Size n,Gen g);
20）includes //检测一个有序序列中是否包含于另一个序列中的每个元素都相等的元素
template<class InIt1,class InIt2>
bool includes(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2);
template<class InIt1,class InIt2,class Pred>
bool includes(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,Pred pr);
21）inplace_merge //将同一序列的两个有序区间[first,middle)和[middle,lase)合并成一个有序区间
template<class BidIt>
void inplace_merge(BidIt first,BidIt middle,BidIt last);
template<class BidIt,class Pred>
void inplace_merge(BidIt first,BidIt middle,BidIt last,Pred pr);
22）merge //将两个不同序列的有序区间合并成一个新的有序区间
template<class InIt1,class InIt2,class OutIt>
OutIt merge(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);
template<class InIt1,class InIt2,class OutIt,class Pred>
OutIt merge(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x,Pred pr);
23）iter_swap //交换不同序列中*x和*y的值
template<class FwdIt1,class FwdIt2>
void iter_swap(FwdIt1 x,FwdIt2 y);
24）lexicographical_compare //用于按字典序比较两个序列，返回bool
template<class InIt1,class InIt2>
bool lexicographical_compare(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2);
template<class InIt1,class InIt2,class Pred>
bool lexicographical_compare(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,Pred pr);
25）make_heap //将制定的[first,last)序列按照operator<顺序或按照函数对象进行重新排列
template<class RanIt>
void make_heap(RanIt first,RanIt last);
template<class RanIt,class Pred>
void make_heap(RanIt first,RanIt last,Pred pr);
26）max //检测两个元素中的较大值
template<class T>
const T& max(const T& x,const T& y);
template<class T,class Pred>
const T& max(const T& x,const T& y,Pred pr);
27）max_element //检测序列中的最大值
template<class FwdIt>
FwdIt max_element(FwdIt first,FwdIt last);
template<class FwdIt,class Pred>
FwdIt max_element(FwdIt first,FwdIt last,Pred pr);
28）min //检测两个元素中的较小值
template<class T>
const T& min(const T& x,const T& y);
template<class T,class Pred>
const T& min(const T& x,const T& y,Pred pr);
29）mix_element //检测序列中的最小值
template<class FwdIt>
FwdIt min_element(FwdIt first,FwdIt last);
template<class FwdIt,class Pred>
FwdIt min_element(FwdIt first,FwdIt last,Pred pr);
30）mismatch //检测两个序列中出现的第一处不相等的地方
template<class InIt1,class InIt2>
pair<InIt1,InIt2> mismatch(InIt1 first,InIt1 last,InIt2 x);
template<class InIt1,class InIt2,class Pred>
pair<InIt1,InIt2> mismatch(InIt1 first,InIt1 last,InIt2 x,Pred pr);
31）next_permutation //改变序列的排序，当序列中所有元素已经是按照升序排列时，返回false
template<class BidIt>
bool next_permutation(BidIt first,BidIt last);
template<class BidIt,class Pred>
bool next_permutation(BidIt first,BidIt last,Pred pr);
32）prev_permutation //改变序列的排序，当序列中所有元素已经是按照降序排列时，返回false
template<class BidIt>
bool prev_permutation(BidIt first,BidIt last);
template<class BidIt,class Pred>
bool prev_permutation(BidIt first,BidIt last,Pred pr);
33）nth_element //要将元素n放置在符合升序顺序的位置处，所有n前面的元素都应小于它，所有n后面的元素都大于它，但对于这些元素没有排序要求
template<class RanIt>
void nth_element(RanIt first,RanIt nth,RanIt last);
template<class RanIt,class Pred>
void nth_element(RanIt first,RanIt nth,RanIt last,Pred pr);
34）partition //将所有使得pr(x)为true的元素移到序列的开始处
template<class BidIt,class Pred>
BidIt partition(BidIt first,BidIt last,Pred pr);
35）partition_sort //将最小的n（middle==first+n）个元素按照升序的方式排列，并将它们移到序列的开始处
template<class RanIt>
BidIt partition_sort(RanIt first,RanIt middle,RanIt last);
template<class RanIt,class Pred>
BidIt partition_sort(RanIt first,RanIt middle,RanIt last,Pred pr);
36）partition_sort_copy //将最小的n（last==first+n）个元素按照升序的方式排列，并将序列复制到[first2,last2)
template<class InIt,class RanIt>
RanIt partition_sort_copy(InIt first1,InIt last1,RanIt first2,RanIt last2);
template<class InIt,class RanIt,class Pred>
RanIt partition_sort_copy(InIt first1,InIt last1,RanIt first2,RanIt last2,Pred pr);
37）pop_heap //从堆中移除值最大的那个元素
template<class RanIt>
void pop_heap(RanIt first,RanIt last);
template<class RanIt,class Pred>
void pop_heap(RanIt first,RanIt last,Pred pr);
38）push_heap //向堆中新增一个元素
template<class RanIt>
void push_heap(RanIt first,RanIt last);
template<class RanIt,class Pred>
void push_heap(RanIt first,RanIt last,Pred pr);
39）random_shuffle //对序列中的元素进行随机重排
template<class RanIt>
void random_shuffle(RanIt first,RanIt last);
template<class RanIt,class Fun>
void random_shuffle(RanIt first,RanIt last,Fun& f);
40）remove //移除所有值为val的元素，返回指向结果序列末端的迭代器值
template<class FwdIt,class T>
FwdIt remove(FwdIt first,FwdIt last,const T& val);
41）remove_copy //移除所有值为val的元素，并把结果存入x中
template<class InIt,class OutIt,class T>
OutIt remove_copy(InIt first,InIt last,OutIt x,const T& val);
42）remove_copy_if //移除所有使得pr(*(first+N))为true的元素，并将结果存入x中
template<class InIt,class OutIt,class Pred>
OutIt remove_copy_if(InIt first,InIt last,OutIt x,Pred pr);
43）remove_if //移除所有使得pr(*(first+N))为true的元素
template<class FwdIt,class Pred>
FwdIt remove_if(FwdIt first,FwdIt last,Pred pr);
43）replace //将序列中值为val_old的元素的值替换为val_new
template<class FwdIt,class T>
void replace(FwdIt first,FwdIt last,const T& val_old,const T& val_new);
44）replace_copy //将序列中值为val_old的元素的值替换为val_new，并将结果存入x中
template<class InIt,class OutIt,class T>
OutIt replace_copy(InIt first,InIt last,OutIt x,const T& val_old,const T& val_new);
45）replace_copy_if //将序列中使得pr(*(first+N))为true的元素的值替换为val_new，并将结果存入x中
template<class InIt,class OutIt,class Pred,class T>
OutIt replace_copy(InIt first,InIt last,OutIt x,Pred pr,const T& val_new);
46）replace_if //将序列中使得pr(*(first+N))为true的元素的值替换为val_new
template<class FwdIt,class Pred,class T>
void replace(FwdIt first,FwdIt last,Pred pr,const T& val_new);
47）reverse //将一个序列反转
template<class BidIt>
void reverse(BidIt first,BidIt last);
48）reverse_copy //将一个序列反转并将结果存入x中
template<class BidIt,class OutIt>
void reverse_copy(BidIt first,BidIt last,OutIt x);
49）rotate //在位置middle处反转序列，使得反转后序列的顺序变为[middle,...,last-1,...first]
template<class FwdIt>
void rotate(FwdIt first,FwdIt middle,FwdIt last);
50）rotate_copy //在位置middle处反转序列，并将结果存入x中
template<class FwdIt,class OutIt>
void rotate_copy(FwdIt first,FwdIt middle,FwdIt last,OutIt x);
51）search //在序列中检测另一个序列第一次出现的地方
template<class FwdIt1,class FwdIt2>
FwdIt1 search(FwdIt1 first1,FwdIt1 last 1,FwdIt2 first2,FwdIt2 last2);
template<class FwdIt1,class FwdIt2,class Pred>
FwdIt1 search(FwdIt1 first1,FwdIt1 last 1,FwdIt2 first2,FwdIt2 last2,Pred pr);
52）search_n //检测序列中第一次出现连续n个元素值为val的地方，或连续n个令pr(*(first+N))==pr(val)的地方
template<class FwdIt,class Size,class T>
FwdIt search_n(FwdIt first,FwdIt last,Size n,const T& val);
template<class FwdIt,class Size,class T,class Pred>
FwdIt search_n(FwdIt first,FwdIt last,Size n,const T& val,Pred pr);
53）set_difference //求两个序列的差集，结果集是包含所有属于第一个序列但不属于第二个序列的元素，返回结果集合的结束位置迭代器
template<class InIt1,class InIt2,class OutIt>
OutIt set_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);
template<class InIt1,class InIt2,class OutIt,class Pred>
OutIt set_difference(InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x,Pred pr);
54）set_intersection //求两个序列的交集，返回结果集合的结束位置迭代器
template<class InIt1,class InIt2,class OutIt>
OutIt set_intersection (InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);
template<class InIt1,class InIt2,class OutIt,class Pred>
OutIt set_intersection (InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x,Pred pr);
55）set_symmetric_difference //求两个序列的差集，结果集是第一个序列相对于第二个的差集并上第二个相对于第一个的差集，返回结果集合的结束位置迭代器
template<class InIt1,class InIt2,class OutIt>
OutIt set_symmetric_difference (InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);
template<class InIt1,class InIt2,class OutIt,class Pred>
OutIt set_symmetric_difference (InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x,Pred pr);
56）set_union //求两个序列的并集，返回结果集合的结束位置迭代器
template<class InIt1,class InIt2,class OutIt>
OutIt set_union (InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x);
template<class InIt1,class InIt2,class OutIt,class Pred>
OutIt set_union (InIt1 first1,InIt1 last1,InIt2 first2,InIt2 last2,OutIt x,Pred pr);
57）sort //按照升序或者自定义的排序函数pr()重排序列[first，last)
template<class RanIt>
void sort(RanIt first,RanIt last);
template<class RanIt,class Pred>
void sort(RanIt first,RanIt last,Pred pr);
58）sort_heap //对堆进行排序，前提是序列中的元素已经是一个堆了
template<class RanIt>
void sort_heap(RanIt first,RanIt last);
template<class RanIt,class Pred>
void sort_heap(RanIt first,RanIt last,Pred pr);
59）stable_partition //将指定序列的元素根据指定的pr函数分成两个子序列，其中满足pr()函数的，即返回值为true的作为第一个序列[v.begin(), bound), 而[bound, v.end())的作为第二个序列
与partition的区别是stable_partition 不会改变原来同一类元素的相对位置
template<class BidIt,class Pred>
BidIt stable_partition(BidIt first,BidIt last,Pred pr);
60）stable_sort //按照升序或者自定义的排序函数pr()重排序列[first，last)，函数可保证相等元素的原本相对次序在排序后保持不变，这里的相等，包含了元素值相等和提供的函数表示两个元素相等
template<class BidIt>
void stable_sort(BidIt first,BidIt last);
template<class BidIt,class Pred>
void stable_sort(BidIt first,BidIt last,Pred pr);
61）swap //交换两个元素的值
template<class T>
void swap(T& x,T& y);
62）swap_ranges //交换两个区间的元素，返回指向第二个容器的第一个没有交换的位置
template<class FwdIt1,class FwdIt2>
FwdIt2 swap_ranges(FwdIt1 first,FwdIt1 last,FwdIt2 x);
63）transform //第一个函数，对序列[first,last)中的每一个元素调用uop(*(first_N))，将结果赋给x；第二个函数对序列[first1,last1)、[first2,last2)中的每一个元素调用
bop(*(first1+N),*(first2+N))，将结果赋给x
template<class InIt,class OutIt,class Unop>
OutIt transform(InIt first,InIt last,OutIt x,Unop uop);
template<class InIt1,class InIt2,class OutIt,class Binop>
OutIt transform(InIt1 first1,InIt1 last1,InIt2 first2,OutIt x,Binop bop);
64）unique //去重函数，去除序列中相邻的重复元素，只保留重复元素中的第一个元素
template<class FwdIt>
FwdIt unique(FwdIt first,FwdIt last);
template<class FwdIt,class Pred>
FwdIt unique(FwdIt first,FwdIt last,Pred pr);
65）unique_copy //去重复制函数，去除序列中相邻的重复元素，只保留重复元素中的第一个元素，再执行copy操作
template<class InIt,class OutIt>
OutIt unique_copy(InIt first,InIt last,OutIt x);
template<class InIt,class OutIt,class Pred>
OutIt unique_copy(InIt first,InIt last,OutIt x,Pred pr);
原文地址：https://www.cnblogs.com/jason-20160301/p/8724709.html