泛型1(一些algorithm函数)

泛型算法本身不会执行容器的操作，它们只会运行于迭代器之上，执行迭代器的操作。因此算法可能改变容器中保存的元素，也可能在容器内移动元素，但永远不会直接添加或删除元素。

只读算法：

accumulate:

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <forward_list>
#include <deque>
#include <string>
using namespace std;

int main(void){
    vector<int> v(10, 1);
    int sum = accumulate(v.cbegin(), v.cend(), 0);
    cout << sum << endl;//10
    sum = accumulate(v.cbegin(), v.cend(), 1);//第三个参数是和的初始值且决定了函数中使用哪个加法运算以及返回值的类型
    cout << sum << endl;//11
    cout << endl;

    list<string> l = {"fjs", "afjkflf", "wwe"};
    string str = accumulate(l.cbegin(), l.cend(), string(""));//注意不能用c风格的字符串,c风格字符串上没有重载+
    cout << str << endl;//fjsafjkflfwwe

    deque<double> q(10, 1.1);
    double cnt = accumulate(q.cbegin(), q.cend(), 0.0);//第三个参数决定了使用何总类型的+
    double cc = accumulate(q.cbegin(), q.cend(), 0);
    cout << cnt << endl;//11
    cout << cc << endl;//10

    return 0;
}

显然，只要支持随机访问(能用迭代器遍历)的容器都支持 accumulate 算法

注意：第三个参数是和的初始值且决定了函数中使用哪个加法运算以及返回值的类型

不能用c风格的字符串,c风格字符串上没有重载+

equal:

#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
using namespace std;

int main(void){
    vector<string> v(5, "hello");
    vector<string> v1(4, "hello");
    list<string> l1(5, "hello");
    list<const char*> l2 = {"hello", "hello", "hello", "hello", "zzz"};
    list<const char*> l3 = {"hello", "hello", "hello", "hello", "zzz"};


    bool flag1 = equal(v.cbegin(), v.cend(), l1.cbegin());//可以两个不同类型的容器之间比较,只要元素之间支持==运算符即可
    bool flag2 = equal(v.cbegin(), v.cend(), l2.cbegin());
    bool flag3 = equal(l2.cbegin(), l2.cend(), l3.cbegin());
    // bool flag4 = equal(v.cbegin(), v.cend(), v1.cbegin());//会运行时出错,只接受一个单一的迭代器来表示第二个序列的算法,都假定第二个序列至少与第一个序列一样长
    cout << flag1 << endl;//1
    cout << flag2 << endl;//0
    cout << flag3 << endl;//1

    cout << endl;

    return 0;
}

注意：可以两个不同类型的容器之间比较,只要元素之间支持 == 运算符即可

只接受一个单一的迭代器来表示第二个序列的算法,都假定第二个序列至少与第一个序列一样长

写容器元素的算法：

fill/fill_n：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main(void){
    vector<int> v, v1, v2;//定义三个空容器
    fill(v.begin(), v.end(), 0);
    fill_n(v1.begin(), v1.size(), 0);

    // fill_n(v2.begin(), 10, 0);//错误,v2是一个空容器,越界了
    v2.reserve(5);//给v2分配5个int的空间
    fill_n(v2.begin(), 5, 0);//v2虽然分配了空间,但其仍然是一个空容器,不改变容器大小无法向其中赋值
    cout << v2.size() << endl;//0
    cout << v2.capacity() << endl;//5
    return 0;
}

注意：使用 fill_n 第一个元素传入一个普通迭代器时如果我们第二个参数不传 v.size() 的话很容易导致越界

fill_n 本身不改变容器的大小，若传给 fill_n 的第一个迭代器是一个普通迭代器的话无法给空容器赋值 

back_inserter：

#include <iostream>
#include <iterator>
#include <vector>
using namespace std;

int main(void){
    vector<int> v1;//空向量
    auto it = back_inserter(v1);
    //back_inserter接受一个指向容器的引用,返回一个与该容器绑定的插入迭代器,当我们通过此迭代器赋值时,
    //赋值运算会调用push_back将一个具有给定值的元素添加到容器中
    *it = 0;//此时v1中有一个元素0
    for(const auto indx : v1){
        cout << indx << endl;
    }

    vector<int> v2(4, 1);
    *back_inserter(v2) = 0;
    for(const auto indx : v2){
        cout << indx << " ";
    }
    cout << endl;//1 1 1 1 0

    vector<int> v3;
    fill_n(back_inserter(v3), 5, 0);//添加10个0到v3中
    for(const auto indx : v3){
        cout << indx << " ";
    }
    cout << endl;//0 0 0 0 0
    return 0;
}

注意：back_inserter 接受一个指向容器的引用,返回一个与该容器绑定的插入迭代器,当我们通过此迭代器赋值时，赋值运算会调用 push_back 将一个具有给定值的元素添加到容器中

fill_n 算法本质是对传入的迭代器的操作，所以给 fill_n 传入普通迭代器时不能改变对应容器的大小，若 fill_n 的第一个迭代器参数是插入迭代器时则其可以改变对应容器的大小并插入指定元素

copy：

#include <iostream>
#include <algorithm>
#include <list>
#include <deque>
#include <vector> 
using namespace std;

int main(void){
    int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int a2[sizeof(a1) / sizeof(*a1)];//a2与a1的大小一样
    auto ret = copy(begin(a1), end(a1), begin(a2));//将a1的内容拷贝到a2,返回目标迭代器递增之后的值
    for(const auto indx : a2){
        cout << indx << " ";
    }
    cout << endl;
    cout << (ret == end(a2)) << endl;//1

    list<int> l(5, 1);
    deque<int> f;
    copy(l.begin(), l.end(), back_inserter(f));
    for(const auto indx : f){
        cout << indx << " ";
    }
    cout << endl;//1 1 1 1 1

    vector<int> v;//空容器
    v.reserve(5);//虽然该容器现在被分配了5个int空间,但其仍然是空容器
    copy(l.begin(), l.end(), back_inserter(v));//向空容器拷入元素,改变了元素大小,必须使用插入迭代器
    cout << v.size() << endl;//5
    cout << v.capacity() << endl;//5
    for(const auto indx : v){
        cout << indx << " ";
    }
    cout << endl;

    vector<int> v1(5);//一个含有5个元素的容器
    copy(l.begin(), l.end(), v1.begin());//只是替换原有元素,不需要用插入迭代器
    for(const auto indx : v1){
        cout << indx << " ";
    }
    cout << endl;//1 1 1 1 1
    return 0;
}

注意：越界问题

对于要改变容器大小的地方不能用普通迭代器

replace/replace_copy

#include <iostream>
#include <algorithm>
#include <forward_list>
#include <vector>
using namespace std;

int main(void){
    forward_list<int> f(10, 0);
    replace(f.begin(), f.end(), 0, 1024);//将f中所有0替换成1024
    for(const auto indx : f){
        cout << indx << " ";
    }
    cout << endl << endl;

    forward_list<int> l(10, 0);
    vector<int> v;
    replace_copy(l.cbegin(), l.cend(), back_inserter(v), 0, 42);//将l拷贝到v并将v中元素值为0的修改成42
    for(const auto indx : l){
        cout << indx << " ";
    }
    cout << endl;
    for(const auto indx : v){
        cout << indx << " ";
    }
    cout << endl;

    return 0;
}

注意：对于要改变容器大小的地方不能用普通迭代器，如：本例中 replace_copy 中因为 v 是个空迭代器，若以第三个参数必须用插入迭代器

重排容器元素的算法：

unique：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

void work(vector<string> &words){
    sort(words.begin(), words.end());//unique只剔除相邻的相同元素
    auto end_unique = unique(words.begin(), words.end());//将相邻的相同的元素"删除",返回一个指向不重复值范围末尾的迭代器
    words.erase(end_unique, words.end());//上面的"删除"并不是真的删除,只是覆盖了而已,我们通过erase真正的将其删除
}

int main(void){
    vector<string> v = {"ac", "ab", "ac", "a", "a"};
    work(v);
    for(const auto indx : v){
        cout << indx << " ";
    }
    cout << endl;//a ab ac

    return 0;
}

注意：unique 只剔除相邻的相同元素

将相邻的相同的元素 "删除"，返回一个指向不重复值范围末尾的迭代器。但其不真正的删除元素，只是将重复的值移到迭代器末尾而已，也可能会将其覆盖

谓词：

谓词是一个可调用的表达式，其返回结果是一个能用作条件的值。标准库算法所使用的谓词分两类：一元谓词(意味着它们只接受单一参数) 和二元谓词(意味着它们有两个参数)。接受谓词参数的算法对输入序列中的元素调用谓词。因此，元素类型必须能转换为谓词参数类型。如：sort 能接受一个二元谓词参数，这个谓词用来代替 < 来比较元素

sort 和 stable_sort：

sort 和 stable_sort 的使用规则完全一样，有区别的是带有 stable 的是稳定排序~

partition 和 stable_partition：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool is_longer_than_5(const string &s){
    return s.size() >= 5;
}

int main(void){
    vector<string> v1 = {"fjskf", "fjslfjksl", "fjsklfk", "f", "fdds", "fjs", "fjslf"};
    vector<string> v2 = {"fjskf", "fjslfjksl", "fjsklfk", "f", "fdds", "fjs", "fjslf"};

    auto pos1 = partition(v1.begin(), v1.end(), is_longer_than_5);//该算法是非稳定的
    auto pos2 = stable_partition(v2.begin(), v2.end(), is_longer_than_5);//该算法是稳定的

    for(auto it = v1.begin(); it != pos1; it++){
        cout << *it << " ";
    }
    cout << endl;

    for(auto it = v2.begin(); it != pos2; it++){
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}