泛型算法参考手册
算法参考的对象序列如下：
int ia[8] = {1,3,6,10,15,21,28,36};//sum = 120
vector<int> ivec(ia, ia+8);
list<int> ilist(ia, ia+8);
string sa[10] =
{
"The", "light", "untonsured",
"hair", "grained", "and",
"hued", "like", "pale",
"oak"
};
vector<string> svec(sa, sa+10);
list<string> slist(sa, sa+10);
accumulate() 元素累加
#include <numeric>
int iresult = accumulate(ia, ia+8, 10);
结果 iresult = 130
也可以传入一个二元运算，如下
int iresult2 = accumulate(ia, ia+8, 100, plus<int>());
adjacent_difference() 相邻元素的差额
#include <numeric>
产生一个新数列，除了第一个元素，每个元素都是原来数列的“相同位置”及前一位置的差。
假设数列为{1,2,3,5,4},那么新的数列是{1,1,1,2,-1}。第三个参数用来存放结果。
adjacent_difference(ilist.begin(), ilist.end(), iresult.begin());
也可以传入一个二元元素，取代默认的“相减”操作：
adjacent_difference(ilist.begin(), ilist.end(), iresult.begin(), multiplies<int());
adjacent_find() 搜索相邻的重复元素
#include <algorithm>
class TwiceOver
{
public:
bool operator()(int val1, int val2)
{return val1 == val2/2 ? true : false;}
};
//搜索第一组“相邻且值重复“的元素,如数列为{1,3,5,5,6},返回5;
int *piter = adjacent_find(ia, ia+8);
// 返回一个iterator
iter = adjacent_find(vec.begin(), vec.end(), TwiceOver()};
binary_search() 二元搜索
该查询假设处理对象以 less-than 运算符排序，如果该容器以其他方式完成排序，那么调用时需要传入该二元原算符。返回true or false
#include <algorithm>
bool found_it = binary_search(ilist.begin(), ilist.end(), 1);
bool found_it = binary_search(ilist.begin(), ilist.end(), 1, greater<int>());
copy() 复制
#include <algorithm>
ostream_iterator<int> ofile(cout, " ");
copy(vec.begin(), vec.end(), ofile);
vector<string> target(svec.size());
copy (svec.begin(), svec.end(), target.begin());
copy_backward() 逆向复制
和copy几乎一样，复制操作逆向行之。
#include <algorithm>
copy (svec.begin(), svec.end(), target.begin());
count() 计数
返回容器中与制定值相等的元素个数
#include <algorithm>
count(svec.begin(), svec.end(), "abc");
count_if() 在特定条件下计数
返回容器中与制定值相等的元素个数
#include <algorithm>
class Even
{
public:
bool operator()(int val)
{return val==6;}//返回等于6的个数
};
int count = count_if(ilist.begin(), ilist.end(), Even());
cout << count;
若 ilist = 3,6,6,8,7则结果为2
equal() 是否相等
若两数列值都相同返回 true,如果第二个数列值较多，多出来的不予考虑，也可以传入一个二元function object 或者 function pointer。
#include <algorithm>
class EqualAndOdd
{
public:
bool operator()(int val1, int val2)
{return val1 != val2;}//返回不等于的状况
};
int ia1[] = {1,2,3,4};
int ia2[] = {1,2,3,4,5,6};
int ia3[] = {0,0,0,0};
bool count1 = equal(ia1, ia1+4, ia2);//true
bool count2 = equal(ia1, ia1+4, ia3, EqualAndOdd());//true
fill() 改填元素值
将容器内每个元素设置为某特定值
#include <algorithm>
fill(ivec.begin(), ivec.end(), value);
fill_n() 改填元素值
将容器内元素设定为某特定值，只设定n个元素
#include <algorithm>
fill_n(ia, count, value);
fill_n(svec.begin(), count, string_value);
find() 搜寻
和特定值比较，找到就结束，返回一个iterator指向该元素，没有找到，返回end().
#include <algorithm>
fill(ivec.begin(), ivec.end(), value);
*p = find(ia, ia+8, 6);
iter = find(svec.begin(), svec.end(), "abc");
find_end() 查找某个子序列最后一次出现的地方
也可以指定一个二元运算
#include <algorithm>
int ia1[] = {1,2,3,4,1,2,3,5,7};
int ia2[] = {1,2,3};
//found_it 指向ia1[4]
found_it = find_end(ia1, ia1 + 9, ia2, ia2+3);
find_first_of() 查找某个子序列第一次出现的地方
也可以指定一个二元运算
#include <algorithm>
int ia1[] = {1,2,3,4,1,2,3,5,7};
int ia2[] = {1,2,3};
//found_it 指向ia1[0]
found_it = find_end(ia1, ia1 + 9, ia2, ia2+3);
find_if() 在特定条件下查找
会被施以一个二元运算
#include <algorithm>
found_it = find_end(vec.begin(), vec.end(), LessThanVal(ival));
for_each() 对范围内的元素施行某个操作
#include <algorithm>
template <typename T>
void print_elem(T elem){cout << elem << " ";}
for_each(ivec.begin(), ivec.end(), print_elem);
generate() 以指定操作的运算结果填充特定范围的元素
#include <algorithm>
class GenByTwo{
public:
void operator()(){
static int seed = -1; return seed+=2;}
};
list<int ilist(5);
//填入ilist的内容为: 1 , 3, 5, 7, 9
generate(ilist.begin(), ilist.end(), GenByTwo());
generate_n() 以指定操作的运算结果填充n个元素
generate_n() 会连续调用指定操作n次， 将n次结果填入序列的n个元素
#include <algorithm>
class GenByTwo{
public:
GenByTwo( int seed =0) :_seed(seed){}
int operator()(){return _seed+=2;}
private:
int _seed;
};
vector<int> ivec(10);
//填入ilist的内容为: 52 , 54, 56, 58, 60
generate(ilist.begin(), ilist.end(), GenByTwo(50));
includes() 涵盖于
如果第二序列内元素都在第一序列中，返回true, 否则返回false,两个序列都必须经过排序， 排序方式可以通过 less-than 运算符（默认）， 或者由第四个参数指定。
#include <algorithm>
int ia1[] = {1,2,3,4,1,2,3,5,7};
int ia2[] = {3,1,2};
//必须排序
sort(ia1, ia1 + 9);
sort(ia2, ia2+3);
res = includes(ia1, ia1+9, ia2, ia2+3)//true
inner_product() 内积
会将两个序列值彼此相乘， 并累加，然后加上某个初始值。
如， {2, 3, 5, 8} 和 {1, 2, 3, 4}, 处理就是： (2*1) + (3*2) + (5*3) + (8*4), 然后加上初始值。
#include <numeric>
int ia1[] = {2, 3, 5, 8};
int ia2[] = {1, 2, 3, 4};
int res = inner_product(ia1, ia2 + 4, ia2, 5);
vector<int> vec1(ia1, ia1 + 4);
vector<int> vec2(ia2, ia2 + 4);
res = inner_roduct(vec1.begin(), vec1.end(), vec2.begin(), 0, minus<int>(), plus<int>());
inplace_merge() 合并并取代（改写）
inplace_merge() 接收3个iterators: first, middle, last, 连个序列必须连续。
也可传入第4个参数，指定 less-than(默认) 运算符以外的操作
#include <numeric>
int ia[8] = {3, 2, 8, 5, 7, 6, 4, 9};
int *middle = ia+4;
int *last = ia +8;
// 2, 3, 5, 8 //4, 6, 7, 9
sort(ia, middle); sort(middle, last);
// 2,3,4,5,6,7,8,9
inplace_merge(ia, middle, last);
iter_swap() 元素互换
将两个iterators 所指向的元素值互换
#include <numeric>
typedef list<int>::iterator iterator;
iterator it1 = list.begin(), it2 = list.begin() +4;
iter_swap(it1, it2);
lexicographical_compare() 以字典排列方式做比较
也可传入第5个参数，指定 less-than(默认) 运算符以外的操作，如果第一序列小于第二序列，返回true.
#include <algorithm>
class size_compare{
public:
bool operator() { const string &a, const string &b){
return a.length() <= b.length();
}
};
string sa1[] = { "piglet", "pooh", "tigger"};
string sa2[] = { "piglet", "pooch", "evyore"};
//false: 'c' < 'h'
res = lexicographical_compare(sa1, sa1+3, sa2, sa2+3);
list<string> ilist1(sa1, sa1+3);
list<string> ilist2(sa2, sa2+3);
//true: pooh < pooch
res = lexicographical_compare(ilist1.begin(), ilist1.end(),
ilist2.begin(), ilist2.end(), size_compare());
max(), min() 最大值/最小值
返回两元素中的最大或者最小值
max_element(), min_e.ement() 最大值/最小值 所在位置
返回一个 iterator， 指向系列中最大（小）元素，如果提供第三参数，可以设定不同比较方式。
#include <algorithm>
vector<int>::const_iterator iter:
iter = max_emement(ivec.begin(), ivec.end());
iter = min_emement(ivec.begin(), ivec.end());
merge() 合并两个序列
