STL 算法整理

<cstdlib>: abort,
<numeric>: accumulate, inner_product,
<memory>: allocator, auto_ptr, uninitialized_copy,
<iterator>: back_inserter, front_inserter, inserter, istream_iterator, ostream_iterator, reverse_iterator,
<new>: bad_alloc,
<typeinfo>: bad_cast, type_info,
<functional>: bind2nd, less_equal, negate, not1, plus,
<bitset>: bitset,
<iostream>: boolalpha, cerr, cin, cout, dec, endl, ends, fixed, flush, hex, internal, istream, left, noboolalpha, noshowbase, noskipws, nounitbuf, nouppercase, oct, ostream, right, scientific, showbase, sowpoint, skippws, unitbuf, uppercase
<algorithm>: copy, count, count_if, equal_range, fill, fill_n, find, find_end, find_first_of, for_each, max, main, nth_element, partial_sort, replace, replace_copy, set_difference, set_intersection, set_union, sort, stable_sort, unique, unique_copy, upper_bound,
<deque>: deque,
<exception>: exception, unexpected,
<fstream>: fstream, ifstream, ofstream,
<string>: getline, string,
<ios_base>: ios_base,
<cctype>: isalpha, islower, ispunct, isspace, isupper,
<sstream>: istringstream, ostringstream, stringstream,
<list>: list,
<stdexcept>: logic_error, out_of_range, range_error, runtime_error,
<utility>: make_pair, pair,
<map>: map, multimap
<set>: multiset, set
<queue>: priority_queue, queue
<cstddef>: ptrdiff_t, size_t,
<iomanip>: setfill, setprecision, setw,
<cmath>: sqrt,
<stack>: stack,
<cstring>: strcmp, strcpy, strlen, strncpy,
<vector>: vector

find(beg,end,val);           在迭代区间[begin,end)内查找等于val的元素，找到返回相应的迭代器，否则返回end。
find_if(beg,end,unaryPred);  函数find的带一个函数参数的_if版本，条件：使函数unaryPred返回true。

find_first_of(beg1,end1,beg2,end2);
find_first_of(beg1,end1,beg2,end2,binaryPred); 
依次遍历元素,在[beg1, end1)中查找首次出现[beg2, end2)中的任一元素,使用==或unarypred相匹配。//注意是任意一个匹配即可。

find_end(beg1,end1,beg2,end2);
find_end(beg1,end1,beg2,end2,binaryPred);
在[beg1,end1)范围内查找[beg2,end2)最后一次出现。找到则返回最后一对的第一个ForwardIterator，否则返回end1。
依次遍历元素，在[beg1, end1）中查找最后一个匹配的子序列[beg2, end2），若存在，则返回beg2在[beg1, end1）中对应的迭代器，否则返回end1。[beg2, end2)中序列必须完全匹配。

adjacent_find(beg,end);
adjacent_find(beg,end,binaryPred);

search(beg1,end1,beg2,end2);
search(beg1,end1,beg2,end2,binaryPred);
依次遍历元素，在[beg1, end1）中查找第一个匹配的子序列[beg2, end2）。若存在，则返回beg2在[beg1, end1）中对应的迭代器，否则返回end1。[beg2, end2)中序列必须完全匹配。

search_n(beg,end,count,val);  //找第n个匹配的
search_n(beg,end,count,val,binaryPred);
依次遍历元素，在[beg1, end1）中查找匹配val的元素，使用==或unarypred匹配。若存在，返回count指定的第count个元素所对应的迭代器，否则返回end1。若count指定值为负数或0，则返回beg1。

count(beg,end,val);
count_if(beg,end,unaryPred);
依次遍历元素，查找范围内与val相匹配或使unarypred为真的元素个数。

for_each(beg,end,f); 	     
将[beg,end)范围内所有元素依次调用函数func，返回func。不修改序列中的元素。

mismatch(beg1,end1,beg2);
mismatch(beg1,end1,beg2,binaryPred);
并行比较[beg1,end1)与[beg2,end2)，指出第一个不匹配的位置，返回一对iterator，标志第一个不匹配元素位置。
如果都匹配，返回每个容器的end。

判断[beg1,end1)与[beg2,end2)内元素都相等
equal(beg1,end1,beg2); 
equal(beg1,end1,beg2,binaryPred);

lower_bound(beg,end,val);
lower_bound(beg,end,val,comp);
从[beg,end)位置二分查找第一个大于或等于val的数字，找到返回该数字的地址，不存在则返回end。
通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

upper_bound(beg,end,val);
upper_bound(beg,end,val,comp);
从[beg,end)位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。
通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

equal_range(beg,end,val);
equal_range(beg,end,val,comp);

fill_n(dest,cnt,val); 将值val赋给[beg,beg+n)范围内的所有元素。
fill(beg,end,val); 将值val赋给[beg,end)范围内的所有元素。

generate_n(dest,cnt,Gen);
generate(beg,end,Gen);

copy(beg,end,dest);
copy_backward(beg,end,dest);
dest是输出序列的尾后迭代器。输入范围内的元素被拷贝或移动到目的序列的尾元素，然后是倒数第二个，类推。返回从beg拷贝或移动的元素的位置。如范围为空则返回dest

将[beg,end)范围内所有元素依次调用函数unary，结果放入res中。
transform(beg,end,dest,unaryOp); 
transform(beg,end,beg2,dest,binaryOp);
将[beg,end)范围内所有元素与[beg2,beg2+end-beg)中所有元素依次调用函数unary，结果放入res中。

replace_copy(beg,end,dest,old_val,new_val);
replace_copy_if(beg,and,dest,unaryPred,new_val);

replace(beg,end,old_val,new_val);
replace_if(beg,end,unaryPred,new_val);

merge(beg1,end1,beg2,end2,dest); 合并[beg1,end1)与[beg2,end2)存放到res。
merge(beg1,end1,beg2,end2,dest,comp);

swap(elem1,elem2);
swap_ranges(beg1,end1,beg2);
iter_swap(iter1,iter2);

inplace_merge(beg,mid,end);
inplace_merge(beg,mid,end,comp);

stable_partition(beg,end,unaryPred); 与partition()类似，保留容器中的相对顺序。
partition(beg,end,unaryPred); 元素重新排序，使用pred函数，把结果为true的元素放在结果为false的元素之前。

sort(beg,end); 默认升序重新排列元素
sort(beg,end,comp);
stable_sort(beg,end); 与sort()类似，保留相等元素之间的顺序关系。
stable_sort(beg,end,comp);

nth_element(beg,nth,end);
nth_element(beg,nth,end,comp);

删除[beg,end)内所有等于val的元素。注意，该函数不是真正删除函数。
采用的办法是:用保留的元素覆盖要删除的元素。算法返回一个迭代器，指向最后一个保留元素的尾后位置。
remove(beg,end,val); 
remove_if(beg,end,unaryPred);
remove_copy(beg,end,dest,val);
remove_copy_if(beg,end,dest,unaryPred);
将所有不等于val元素复制到res，返回OutputIterator指向被拷贝的末元素的下一个位置。

重排序列，对于相邻的满足条件的元素，通过覆盖来进行删除，返回一个迭代器，指向最后一个保留元素的尾后位置。
unique(beg,end);
unique(beg,end,binaryPred);
unique_copy(beg,end,dest);
unique_copy(beg,end,dest,binaryPred);
与unique类似，不过把结果输出到dest。

rotate(beg,mid,end);
rotate_copy(beg,mid,end,dest);

reverse(beg,end);
reverse_copy(beg,end,dest);

random_shuffle(beg,end); 元素随机调整次序。
random_shuffle(beg,end,rand); 使用函数gen代替随机生成函数执行random_shuffle()。

is_permutation(beg1, end1, beg2)
is_permutation(beg1, end1, beg2, binaryPred)

next_permutation(beg,end);
next_permutation(beg,end,comp);

int a[6]={1,2,3,4,5,6};
do{
	for(int i=0;i<6;i++)
		cout<<a[i]<<' ';
	cout<<endl;
}while(next_permutation(a,a+6));

prev_permutation(beg,end);
prev_permutation(beg,end,comp);

includes(beg,end,beg2,end2);
includes(beg,end,beg2,end2,comp);

set_union(beg,end,beg2,end2,dest);
set_union(beg,end,beg2,end2,dest,comp); 将函数comp代替<操作符，执行set_union()

set_intersection(beg,end,beg2,end2,dest);
set_intersection(beg,end,beg2,end2,dest,comp); 将函数comp代替<操作符

set_difference(beg,end,beg2,end2,dest);
set_difference(beg,end,beg2,end2,dest,comp); 将函数comp代替<操作符

set_symmetric_difference(beg,end,beg2,end2,dest);
set_symmetric_difference(beg,end,beg2,end2,dest,comp);

min(va1,va2);            返回两个元素中较小一个。
min(val1,val2,comp);
max(val1,val2);
max(val1,val2,comp);     返回两个元素中较大一个。

min_element(beg,end);    返回一个ForwardIterator，指出[beg,end)中最大的元素。
min_element(beg,end,comp);
max_element(beg,end);    返回一个ForwardIterator，指出[beg,end)中最小的元素。
max_element(beg,end,comp);

lexicographical_compare(beg1,end1,beg2,end2);      按字典序判断[beg1,end1)是否小于[beg2,end2)
lexicographical_compare(beg1,end1,beg2,end2,comp); 将函数comp代替<操作符

对[beg,end)内元素之和，加到初始值val上。
accumulate(beg,end,init);
accumulate(beg,end,init,BinaryOp);
将函数BinaryOp代替加法运算，执行accumulate()。

将[beg,end)内该位置前所有元素之和放进dest中。
partial_sum(beg,end,dest);
partial_sum(beg,end,dest,BinaryOp);

对两个序列做内积(对应元素相乘，再求和)并将内积加到初始值init上。
inner_product(beg1,end1,beg2,init);
inner_product(beg1,end1,beg2,init,BinOp1,BinOp2);

adjacent_difference(beg,end,dest);
adjacent_difference(beg,end,dest,BinaryOp);