泛型算法

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

accumulate:

#include<bits/stdc++.h>
using namespace std;
int main(){
    int a[100];
    for(int i=0;i<100;i++)a[i]=i;
    int sum=accumulate(a,a+100,0);
    cout<<sum;
}

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

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

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

equal:

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<int> a(100),b(100);
    for(int i=0;i<100;i++)a[i]=i;
    for(int i=0;i<100;i++)b[i]=i;
    if(equal(a.begin(),a.end(),b.begin()))cout<<"equal";
    else cout<<"NO";
}

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

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

fill

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<int> a(100),b(100);
    fill(a.begin(),a.end(),10);
    fill_n(vec.begin(),102,0);//提供一个迭代器，一个大小，一个值
    return 0;
}

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

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

back_inserter

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<int> vec(100,3);
    auto it=back_inserter(vec);
    *it=4;
    *it=5;//插入了两个元素，4和5
    fill_n(back_inserter(vec),10,33);//通过fill_n添加10个元素。
    return 0;
}

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

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

copy、replace、replace_copy

#include<bits/stdc++.h>
using namespace std;
int main(){
    int a[10]={0,1,2,3,4,5,6,7,8,9};
    int b[sizeof(a)/sizeof(*a)];
    auto ret = copy(begin(a),end(a),b);
    if(ret==end(b))cout<<"返回值指向b位置迭代器递增之后的地方。"<<endl;

    replace(begin(b),end(b),9,10);//将所有元素为9的值都改变为10

    replace_copy(begin(b),end(b),begin(a),9,10);//希望之前的地方的值不变，将改变后的值存放在另一个容器中，那么就使用replace_cooy(接收第三个迭代器参数)
    for(int i=0;i<=9;i++)cout<<a[i]<<" "<<b[i]<<endl;

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
    int a[10]={0,1,2,3,4,5,6,7,8,9};
    int b[sizeof(a)/sizeof(*a)];

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

    vector<int> vec(5);
    copy(l.begin(),l.end(),back_inserter(vec));
    for(auto x:vec)cout<<x<<" ";cout<<endl;//改变了元素的大小。
    return 0;
}

unique

#include<bits/stdc++.h>
using namespace std;
int main(){
    srand(time(NULL));
    vector<int> vec(30,10);
    for(int i=1;i<=30;i++)vec[i]=rand()%11;
    for(auto x:vec)cout<<x<<" ";cout<<endl;

    sort(vec.begin(),vec.end());
    auto it=unique(vec.begin(),vec.end());
    vec.erase(it,vec.end());
    for(auto x:vec)cout<<x<<" ";cout<<endl;
    return 0;

}

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

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

stable_sort

#include<bits/stdc++.h>
using namespace std;
int main(){
    vector<string> vec;
    for(int i=1;i<=10;i++){
        string s;
        cin>>s;
        vec.push_back(s);
    }
    stable_sort(vec.begin(),vec.end());
}
/*
123
5644896
216541
2131
154532
1561
125489
156498
156565
65563
*/

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

partition

std::partition会将区间[first,last)中的元素重新排列，满足判断条件pred的元素会被放在区间的前段，不满足pred的元素会被放在区间的后段。该算法不能保证元素的初始相对位置，如果需要保证初始相对位置，应该使用stable_partition.

#include<bits/stdc++.h>
using namespace std;
bool cmp(string s){
    return s.size()<=5;
}
int main(){
    vector<string> v1 = {"fjskf", "fjslfjksl", "fjsklfk", "f", "fdds", "fjs", "fjslf"};
    vector<string> v2 = {"fjskf", "fjslfjksl", "fjsklfk", "f", "fdds", "fjs", "fjslf"};
    auto x1=partition(v1.begin(),v1.end(),cmp());//将满足条件的放在前面，不满足条件的放在后面，不保证稳定。
    auto x2=stable_partition(v2.begin(),v2.end(),cmp());//将满足条件的放在前面，不满足条件的放在后面，保证稳定。
}