泛型算法參考手冊

算法參考的對象序列以下：
    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() 合併兩個序列