STL基础语法总结

STL基础语法总结

cplusplus手册
cppreference手册
顺序容器:元素排列的顺序不依赖元素值大小，而是由元素添加到容器的顺序决定。
顺序容器类型:vector、list(双向链表)、forward_list(单向链表)、deque(双端队列) 、array(固定大小数组)、string(字符串)
关联容器包括set、map,关联容器中的元素是按关键字来保存和访问的。
顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的。

注意:容器操作彼此之间类似,有些操作没有写，不代表不能用。

STL之string

#include <string>
string s1;
sting s2(s1);
string s3("value");
string s3 = "value"; //c++中不建议这种写法。
string s4(n, 'c');
string s5(s4.begin(), s4.end());
const char *cp = "666";
char c_array[] = "345";
char c_array2[] = {'a', 'b'};
string s(cp);
string s(c_array);
string s(c_array2, 2);
string s2(s,start_index,end_index);
s.insert(iterator,c);//迭代器iterator 前面插入字符
s.insert(iterator,n,c);//迭代器iterator 前面插入n个字符
s.insert(iterator,a.begin(),a.end());//范围插入
s.assign(a.begin(),a.end());//迭代器赋值
s.assign(n,c)//赋值n个字符
s.erase(iterator)//迭代器删除
s.erase(iterator_start,iterator_end)//迭代器范围删除
s.insert(index,n,c)//索引前面插入n个字符
s.insert(index,s1)//索引前面插入s1
s.insert(index,s1,index2,len)//索引前面插入s1中index2开始len个字符char *p = "xxx";
s.assign(p,len),s.assign(p)//部分赋值/赋值
s.insert(index,p,len),s.insert(index,p)//index前面 部分插入/插入s.assign(s2,index2,len),s.assign(s2)//部分赋值/赋值
s.erase(index,len)//index开始 删除len个cin << s1;//读取字符串,忽略最前面的空格,遇到非空格开始读,直到空格结束。
string name;
while(getline(cin, name)) //读取一行,然后输出,ctrl+z结束。
{cout << name << endl;
}
s.empty();      // 判空
string::size_type size = s.size();       // 字符个数
s[n];           // s中索引n的字符的引用,可以做为左值(比如:s[0] = '*',修改字符串第1个字符)。
s1+s2;          // s1和s2连接
<,<=,>,>=,==    // 比较
string name = "6" + "jh";//两个字符串字面值不可以加,需要最低有一个字符串变量。
#include <cctype> //引入c语言标准库练习。
------------------------查找操作-------------------------------------
可以传index索引,从某位置开始找。
string s("abca")
string::size_type r = s.find("ab");//精确查找,如果找到就返回下标
if (r == string::npos)
{cout << "no find" << endl;
}
else
{cout << r  << endl;//打印下标
}
s.rfind("a");//反向精确查找
s.find_first_of("adf");//s中找a d  f 任意一个
s.find_first_not_of("adf");//s中找不是 a d  f的
s.find_last_of("asd");//s中反向找a s d任意一个
s.find_last_not_of("asd");//s中反向找不是a s d中任意一个
----------------------------比较-----------------------------------
int spare(s2); s大,返回值大于0,s小返回值小于0,否则等于0
spare(index,len,s2)//s的一部分和s2比较
spare(index,len,s2,index2,len2) //s的一部分和s2一部分比较
const char *p = "455";
spare(p);
spare(index,len,p);s的部分很p比较
spare(index,len,p,len2);//s的部分和p的前len2个字符比较。
spare(index,len,p,index2,len2);s的部分和p的部分比较
------------------------------------------------------------------
string特有操作
string s("abc");
s2 = s.substr() 等价于 s2 = s;
s2 = s.substr(index)
s2 = s.substr(indexFrom,len)
s.append("77");//追加
s.replace()//替换

STL之vector

#include <vector>
//vector是一个类模板(class template),动态数组。
vector<T> v1;
vector<T> v2(v1);
vector<T> v2 = v1;
vector<T> v3(n, val);//n个值为val。
vector<T> v4(n);//含n个默认初始化值的vector,(int默认0,string默认"")。
vector<T> v5{a,}
vector<T> v5={a,}
//如果用圆括号,那么提供的值是用来构造vector对象的。
//如果用花括号,则是使用列表初始化该vector对象。
vector<int> b(a);  //开一个vector名字为b并将a的值全部复制给b
vector<int> b(a.begin(),a.end());//同上
vector<int> b(a,a+5);//a是数组
vector<int> b(&a[0],&a[5]);//同上
v.empty();
vector<int>::size_type size = v.size();
v.push_back(t);
v[n]; //是引用,可以做左值。
a.at(i);//同上
a.pop_back();  //将a的末尾元素出栈(返回值为void类型)
a.font()/a.back(); //返回第一个/最后一个元素,可以引用接收值。不检查这个数据是否存在。
a.clear();  //清除a中所有的元素
a.insert(iterator,x);  //在it前添加x
a.insert(iterator,n,x);  //在it前添加n个x
a.max_size();  //返回vector的最大容量
a.erase(it);  //删除it这个迭代器所指向的值,返回下一个迭代器。
a.erase(first_it,last_it);  //删除从[first_it,last_it)的值,返回下一个迭代器。
a.resize(n); //改变长度,超过的话则删除多余部分,少的话则增添默认值
a.resize(n,x); //同上,默认值改为x
注意resize可能导致迭代器失效!!!
a.swap();//交换元素,类型必须一样。
a.assign(b_it,e_it) 将[b_it;e_it)区间中的数据赋值给c。
c.assign(n,elem)：将n个elem的拷贝赋值给c。
//反向迭代器,rbegin()相当于end()-1,rend()相当于begin()+1
for (vector<int>::reverse_iterator iter = a.rbegin(); iter != a.rend(); iter++)
{cout << *iter << endl;
}
可以借助算法库进行反转reverse(),排序sort(),二分查找binary_search()。
class Cat
{
public:Cat(int a):a(a), b(0) {}
private:int a;int b;   
};
vector<Cat> b;//空向量
vector<Cat> b2(10)//报错,Cat没有默认构造函数。
vector<Cat> b2(10,2);//10个Cat,默认会调用一个参数的构造,如果没有则报错。
vector<int> a(10,2);
vector<int>::difference_type t = a.end() - a.begin();两个迭代器之间的距离。

vector中的resize()和reserve()
1、resize()可以改变有效空间的大小，reserve()只会改变当前容器的“容量”大小。
2、当resize()改变了size后，capacity也可能被改变。
3、但当reserve()改变了capacity后，size()并不会变化。
4、void reserve(size_type n)，假如调用之前容器的容量是m，如果n > m，在自由内存区为整个容器重新分配一块新的更大的连续空间(vector是存储空间连续的，所以只能重新分配)，然后将容器内所有的有效元素从旧位置全部复制到新位置，这个过程是调用拷贝构造函数，释放旧位置的所有存储空间。如果n < m，调用无效。
5、真实改变容器的大小，多(删元素)少补(元素，并授予默认值)。

vector、deque、list可以进行关系运算，如果类型是类类型，这个类需要重载关系运算符。
vector和deque，特有的操作: a[n],a.at(n);下标不存在报错。

STL之deque

deque与vector非常相似。它也采用动态数组管理元素，不同的是deque的动态数组头尾都开放，因此能在头尾两端进行快速安插和删除。

#include <algorithm>//算法库
#include <deque>
int main(int argc, char **argv)
{deque<int> a;a.push_back(2);//后面插入元素a.push_back(4);a.push_back(6);a.push_front(1);//从前面插入元素a.pop_front();//前面删除一个元素a.pop_back();//后面删除一个元素//支持下标和迭代器遍历for (deque<int>::iterator iEle = a.begin();iEle != a.end(); iEle++){//distance计算距离,返回的是这个元素的下标size_t nOffset = distance(a.begin(), iEle);cout << nOffset << "t" << *iEle << endl;}return 0;
}

insert(pos_iterator,elem)在pos位置插入一个elem。
insert(pos_iterator,n,elem)在pos位置插入n个elem。
insert(pos_iterator,beg_iterator,end_iterator)在pos位置插入[beg,end)区间的数据。
clear()清空。
erase(beg_iterator,end_iterator);删除[beg,end)区间的数据,返回下一个数据的位置(迭代器)。
erase(pos);删除pos位置的数据,返回下一个数据的位置(迭代器)。

STL之list

#include <list>//链表结构
list<int>lst1;       //创建空list
list<int> lst2(5);   //创建含有5个元素的list,并且赋予默认值。
list<int>lst3(3,2);  //创建含有3个元素的list。
list<int>lst4(lst2);  //使用lst2初始化lst4
list<int>lst5(lst2.begin(),d());//同lst4
list1.assign() 给list赋值
list1.insert() 插入一个元素到list中。
list1.pop_back() 删除最后一个元素。
list1.pop_front() 删除第一个元素。
list1.push_back() 在list的末尾添加一个元素。
list1.push_front() 在list的头部添加一个元素。
list1.back() 返回最后一个元素。
list.front() 返回第一个元素。
list.clear() 删除所有元素。
pty() 如果list是空的则返回true。
ase(_iterator)删除。
begin()/end()正向迭代器。
rbegin()/rend()逆向迭代器。
ve(key) 移除元素。
ve_if([](int n) {return n%2 == 0;});条件移除元素。
list.unique()删除重复元素。
verse()反转。
list.size()个数。
list.sort()排序。
()合并 或合并后排序。//(list2);(list2,compare);
list.swap()交换。类型必须一样。
size()重置元素个数,缺补多删。
list.splice();合并。
void splice(iterator pos, list& y); 
void splice(iterator pos, list& y, iterator pos1);
void splice(iterator pos, list& y, iterator first, iterator last);
pos y 插入的位置。
pos1 指向(y)的元素被传输到调用者。
first,last定义被传输的范围。
int main(int argc, char **argv)
{list<int> a {1,3,5};list<int> b{2,4,6};//a.splice(a.begin(), b);//a-->2 4 6 1 3 5  b变成空list<int>::iterator aitr = a.begin();list<int>::iterator bitr = b.begin();bitr++;a.splice(aitr, b, bitr);//a-->4 1 3 5 b-->2 6list<int>::iterator aitr = a.begin();list<int>::iterator bitr = b.begin();bitr++;a.splice(aitr, b, bitr, b.end());//a-->4 6 1 3 5 b--> 2for(list<int>::iterator i = a.begin(); i != a.end(); i++){cout << *i << endl;}cout << "-----------" << endl;for(list<int>::iterator i = b.begin(); i != b.end(); i++){cout << *i << endl;}return 0;
}

STL之stack

stack容器适配器的模板有两个参数。第一个参数是存储对象的类型，第二个参数是底层容器的类型。stack 的底层容器默认是 deque 容器，因此模板类型其实是 stack<typename T, typename Container=deque>。通过指定第二个模板类型参数，可以使用任意类型的底层容器(vector, deque，list等)，只要它们支持 back()、push_back()、pop_back()、empty()、size() 这些操作。

#include <stack>
empty()//堆栈为空则返回真
pop() //移除栈顶元素
push()//在栈顶增加元素
size() //返回栈中元素数目
top() //返回栈顶元素

STL之queue

queue容器适配器的模板有两个参数。第一个参数是存储对象的类型，第二个参数是底层容器的类型。默认deque容器，也支持list。

#include <queue>
front():返回 queue 中第一个元素的引用。
back():返回 queue 中最后一个元素的引用。
push(item) 添加元素。
pop():删除 queue 中的第一个元素。
size():返回 queue 中元素的个数。
empty():如果 queue 中没有元素的话，返回 true。
emplace():用传给 emplace()的参数调用 T 的构造函数,在queue的尾部生成对象。
swap(queue &other_q):将当前queue中的元素和参数queue中的元素交换。它们需要包含相同类型的元素,也可以调用全局函数模板swap()来完成同样的操作。

STL之优先级队列

priority_queue< type, container, function >
type：数据类型；
container：实现优先队列的底层容器(必须数组形式实现的容器)，支持deque、vector；
function：元素之间的比较方式；

#include <queue>
priority_queue<int,deque<int>> a; //定义队列,默认为大顶堆。
bool empty() const//返回值为true，说明队列为空。
int size() const//返回优先队列中元素的数量。
void pop()//删除队列顶部的元素，也即根节点。
int top()//返回队列中的顶部元素,但不删除该元素；
void push(item)//插入到队列之中。
//构建大顶堆的方法
priority_queue<int,vector<int>,less<int> > big_heap2;   
//此优先队列是一个小顶堆
priority_queue<int,vector<int>,greater<int> > small_heap;
使用less<int>和greater<int>,需要头文件:#include <functional>
int main(int argc, char **argv)
{priority_queue<int,deque<int>,greater<int>> a;a.push(4);a.push(1);a.push(10);while (!a.empty()){cout << a.top() << endl; //输出1  4  10a.pop();}return 0;
}

STL之set

set的元素不像map那样可以同时拥有实值(value)和键值(key),set元素的键值就是实值，实值就是键值。set不允许两个元素有相同的键值。

#include <set>
begin()/end()//正向迭代器
rbegin()/rend()//反向迭代器
clear()//清除所有元素
count()//返回某个值元素的个数
empty()//如果集合为空，返回true
erase()//删除元素
find()//返回一个指向被查找到元素的迭代器
insert()//在集合中插入元素
lower_bound()//返回指向>=某值的第一个元素的迭代器
upper_bound()//返回指向>某值的第一个元素的迭代器
size()//个数
swap()//交换
equal_range()//返回集合中与给定值相等的上下限的两个迭代器

multiset可以重复,set不可以重复。

STL之map

#include <map>
int main(int argc, char **argv)
{map<int, string> a;a.insert(map<int,string>::value_type(1,"千任雪"));a.insert(make_pair(-1, "唐三"));a.insert(pair<int,string>(2, "武学"));a[4] = "数组格式";cout << "map一共:" << a.size() << endl;map<int, string>::const_iterator i;for (i = a.begin(); i != a.end(); i++){cout << i->first << "t" << i->second.c_str() << endl;}multimap<int,string> ma;ma.insert(multimap<int,string>::value_type(1, "mtree"));ma.insert(make_pair(2,"千任雪"));ma.insert(pair<int,string>(2,"千任雪"));cout << "multimap:" << ma.size() << endl;multimap<int,string>::const_iterator mi;for (mi = ma.begin(); mi != ma.end(); mi++){cout << mi->first << "t" << mi->second.c_str() << endl;}return 0;
}

算法库

#include <algorithm>
预定义函数对象
less<type>小到大,greater<type>大到小,modulus<type>模运算
less_equal<type>小于等于
negate<type>() 取负数
multiplies<type>()乘法,divides<type>()除法
plus<type>()加,minus<type>()减
equal_to<tpye>()等于,not_equal_to<tpye>()不等于
greater_equal<type>()大于等于,less_equal<type>()小于等于
logical_not<type>()逻辑非,logical_or<type>()逻辑或,logical_and<type>()逻辑与函数适配器
bind2nd(op,value)二元函数转换为一元函数。将给定值绑定到二元函数对象的第二个实参。
bind1st(op,value)将给定值绑定到二元函数对象的第一个实参。
not1(op) 对一元函数对象求反的取反器。
not2(op) 是对二元函数对象求反的取反器。
mem_fun/mem_fun_ref 
ptr_fun(op)//自动排序的红黑树,less<type>从小到大,greater<type>从大到小
set<int, less<int>> a;
a.insert(2);
a.insert(1);
a.insert(3);
for(set<int, less<int>>::iterator i = a.begin(); i != a.end(); i++)
{cout << *i << endl;
}void print(int e)
{printf("%dt", e);
}
class pringInt
{public:void operator()(int e) const{cout << e << "t";}
};
遍历,第三个参数传函数或函数对象
for_each(a.begin(), a.end(), print);
for_each(a.begin(), a.end(), pringInt());计数count count_if
关联容器和它等效的成员函数:unt
vector<int> a;
a.push_back(2);
a.push_back(1);
a.push_back(3);
int num = count(a.begin(), a.end(), 2);//统计2的个数
bool isEvent(int e)
{return e % 2 == 0;
}
统计偶数的个数,第三个参数传一元谓词(函数或函数对象[谓词])
int num = count_if(a.begin(), a.end(), isEvent);
函数适配器bind2nd,判断大于0的                       param1 > param2
int num = count_if(a.begin(), a.end(), bind2nd(greater<int>(), 0));
统计奇数的个数                                      param1 % 2 返回1代表true
int num = count_if(a.begin(), a.end(), bind2nd(modulus<int>(), 2));
not1函数适配器,取反。统计偶数的个数 
int num = count_if(a.begin(), a.end(), not1(bind2nd(modulus<int>(), 2)));最大最小值
二元谓词--->绝对最小值
bool absLess(int e1,int e2)
{return abs(e1) < abs(e2);
}
max_element(a.begin(),a.end());
max_element(a.begin(),a.end(),二元谓词);
min_element(a.begin(),a.end());
min_element(a.begin(),a.end(),二元谓词);查找算法
find(a.begin(), a.end(), 3);//线性查找
find_if(a.begin(), a.end(), 函数或函数对象[谓词]);//线性查找
关联容器查找有自带成员函数 find() //对数复杂度
string 不能使用上面的查找,必须用自带的find();
distance(a.begin(), pIterator);//当前迭代器的索引,部分容器适用search_n(a.begin(), a.end(), x, v);查找连续的x个v,返回第一个x的迭代器
search_n(a.begin(), a.end(), x, v, 函数或函数对象[谓词]);
search_n(a.begin(), a.end(), 3, 1, greater<int>());//查找连续3个大于1的//两个容器彼此查找
search()从前面查找 / find_end()从后面查找deque<int> d{1,2,3,4};list<int> l{3,4};
deque<int>::iterator pos = d.begin();      
pos = search(d(),l.begin(),l.end());
if (pos != d.end()) {cout << *pos;
}    bool checkEven(int ele, bool even) {if (even) return ele % 2 == 0;return ele % 2 == 1;
}
vector<int> d{2,3,4,5,6,7,2};
bool checkEvenArg[3] = {true, false, true}; //查找连续的偶数奇数偶数
vector<int>::iterator pos = search(d.begin(),d.end(),checkEvenArg,checkEvenArg + 3, checkEven);
while (pos != d.end()) {cout << *pos << "t";pos++;
}    find_first_of 从前面开始找任意一个,找到其返回迭代器。
第五个参数可以加谓词。
deque<int> d{1,2,3,4};
list<int> l{8,4};
deque<int>::iterator pos = find_first_of(d.begin(),d.end(),l.begin(),l.end());
while (pos != d.end()) {cout << *pos << "t";pos++;
}
从后面查找任意一个中的 第一个出现的值
deque<int>::reverse_iterator pos = find_first_of(d.rbegin(),d.rend(),l.begin(),l.end());deque<int> d{2,2,2,4};
deque<int>::iterator pos;
pos = adjacent_find(d.begin(), d.end());//查找连续两个相等的值
if (pos != d.end()) cout << "位置" << distance(d.begin() ,pos) + 1; bool doubled(int ele1,int ele2) {return ele2 == ele1 * 2;
}
adjacent_find(d.begin(), d.end() ,doubled);查找两个连续且第二个数是第一个数的二倍已序区间查找
deque<int> d{1,2,4,7,9};
list<int> l{1,9};
bool b = binary_search(d.begin(), d.end(), 7);//二分查找7
binary_search(d.begin(), d.end(), val,谓词);//谓词指定排序规则
//已序范围查找,按照顺序 挨个 查,全部找到返回true。
bool i = includes(d.begin(), d.end(),l.begin(),l.end());lower_bound(l.begin(),l.end(),val);//查找非递减序列第一个小于等于val出现的迭代器
upper_bound(l.begin(),l.end(),val);//返回非递减序列第一个大于val的迭代器
equal_range等效上面两个加起来
list<int> l{1,2,2,3,3,4,5,6,7,8,9};
pair<list<int>::iterator, list<int>::iterator> range = equal_range(l.begin(),l.end(),2);
cout << distance(l.begin(), range.first) + 1 << "t" << distance(l.begin(), range.second) + 1;
关联容器有自带的方法和他们等效。for_each
void print(int ele) {cout << ele << endl;
}
template<class T>
class AddValue {private:T value;public:  AddValue(const T &v):value(v) {}void operator() (T &ele) {//由于它的调用语法与函数调用完全一致,故有称函数对象ele += value;}
};class avgValue{private:long num;long sum;public: avgValue():num(0),sum(0){}void operator() (int ele) {num++;sum += ele;}   double value() {return static_cast<double>(sum) / static_cast<double>(num);}operator double() {//重载double类型转换操作符return static_cast<double>(sum) / static_cast<double>(num);}
};list<int> l{1,2,3,3,4};
avgValue res = for_each(l.begin(),l.end(), avgValue());
cout << "平均值:" << res.value();
double ans = for_each(l.begin(),l.end(), avgValue());//前提重载类型转换操作符
cout << "平均值:" << ans;//AddValue<int> add(10);
//for_each(l.begin(),l.end(), add);
for_each(l.begin(),l.end(), AddValue<int>(10));//传入AddValue构造
for_each(l.begin(),l.end(), print);equal
bool bothEvenOrOdd(int ele1,int ele2) {return ele1 % 2 == ele2 % 2;
}
deque<int> d{1,2,3,3,4};
list<int> l{1,2,3,3,6};
equal(d.begin() ,d.end() ,l.begin());//两个容器是否相等
equal(d.begin() ,d.end() ,l.begin(),bothEvenOrOdd);//两个容器奇偶性是否相等pair<deque<int>::iterator,list<int>::iterator> pair;
pair = mismatch(d.begin(),d.end(),l.begin());//找第一个不相等的数,返回其两个容器的迭代器
pair = mismatch(d.begin(),d.end(),l.begin(),less_equal<int>());//查找大于的值,less_equal小于等于。区间比较大小,从第一个开始比较大小。第五个参数可以传函数对象。
检查第一个范围[first1, last1)是否按字典序小于第二个范围[first2, last2)。
lexicographical_compare(d.begin(),d.end(),l.begin(),l.end());copy
copy(d.begin(),d.end(),l.begin());//从d的前面copy过去,l的容量(size())要够用。
copy_backward(d.begin(),d.end(),l.end());//从d最后一个元素开始直到第一个元素。
copy(d.begin(),d.end(), back_inserter(l));//插入迭代器copy,不需要保证l的容量。#include <iterator>
std::ostream_iterator<int> out_iter(std::cout, " ");
copy(d.begin(),d.end(), out_iter);//copy到输出流
copy(d.rbegin(),d.rend(), out_iter);//反着copy
copy(d.begin() + 0,d.begin() + 3, d.begin() + 4);//同一个容器内copy
没有copy_if()算法,可以使用remove_copy_if().
算法复制过程中要逆转元素次序,使用reverse_copy()算法.
把容器内所有元素赋值给另一个容器,要使用赋值操作符或容器的assign()成员函数.
复制过程中删除案些元素,使用remove_copy()和remove_copy_if()算法.
复制中改变元素,使用transform()或replace_copy()算法.transform
transform(begin1,end1,begin2,op)/transform(begin1,end1,begin2,begin3,op)
deque<int> d{1,-2,3,3,4};
list<int> l;
transform(d.begin(), d.end(), d.begin(), negate<int>());//d容器取负值
transform(d.begin(), d.end(), //数据乘以10并插入到l容器back_inserter(l), bind2nd(multiplies<int>(), 10));
transform(l.begin(), l.end(),//变换到输出流std::ostream_iterator<int>(std::cout, " "), negate<int>());
transform(l.begin(), l.end(),//自己乘以自己l.begin(), l.begin() ,multiplies<int>());
transform(d.begin(), d.end(),//d容器前后分别相加d.rbegin(), back_inserter(l), plus<int>());
transform & for_each区别
transform 速度慢 非常灵活
for_each  速度快 不灵活void square(int &ele) {ele = ele * ele;
}
int square2(int ele2) {return ele2 * ele2;
}
for_each(d.begin(), d.end(), square);
transform(d.begin(), d.end(), d.begin(), square2);交换
deque<int> d{1,-2,3,3,4};
list<int> l{2,4,7};
list<int>::iterator res = swap_ranges(d.begin(), d.end(), l.begin());
返回l容器第一个没有交换的数的迭代器。
swap_ranges(d.begin(), d.end() + 2, d.rbegin());//前后交换
同一个容器交换,应该使用容器的swap()函数,速度快
vector<int> a{1,2};
vector<int> d{10,20};
a.swap(b);
a = b;赋值操作慢,只把b的值给a。填充
deque<int> d{1,-2,3,3,4};
list<int> l;
fill(d.begin(), d.end(), 0); 全部填充0
fill_n(back_inserter(l), 5, 1); 添加5个1
fill_n(std::ostream_iterator<int>(std::cout, " "), 5, 1);
填充随机数
generate_n(back_inserter(l), 5, rand);
generate(d.begin(), d.end(), rand);替换
deque<int> d{1,-2,3,3,4};
list<int> l;
replace(d.begin(), d.end(), 1, 8); l容器中的1替换为8.
replace_if(d.begin(), d.end(), bind2nd(less<int>(), 5), 0);小于5的替换为0.
replace_copy(d.begin(), d.end(), back_inserter(l), -2, 8);copy到l容器,并且-2替换为8.
replace_copy_if(d.begin(), d.end(),std::ostream_iterator<int>(std::cout, " "),
bind2nd(modulus<int>(),2), 0); 奇数替换为0并输出.删除
remove 并不是真正的删除,而是把后面的元素向前移动,覆盖被删除的元素。
返回逻辑终点的迭代器。
vector<int> d {2,4,6,6,2,8};
vector<int>::iterator newend = remove(d.begin(), d.end(), 6);
cout << "删除了几个元素?t" << distance(newend, d.end());
d.erase(newend, d.end()); //真正的删除元素。
d.erase(remove_if(d.begin(), d.end(), bind2nd(less<int>(),4)), d.end());//删除小于4的//条件删除copy
remove_copy_if
remove_copy
vector<int> d{10,9,2,5,3,7,101,18};
multiset<int> set;
remove_copy_if(d.begin() ,d.end(), //copy到set容器,小于4的不copyinserter(set, d()),bind2nd(less<int>(), 4));remove_copy(d.begin(),d.end(), //copy到输出流,[删除]4不输出std::ostream_iterator<int>(std::cout," "), 4);//unique去连续重复元素,后面的元素向前补位
//9,9,10,18 删除后-> 9,10,18,18  返回最后一个元素的下一个迭代器(这里是最后一个18).      
vector<int>::iterator pos = unique(d.begin() ,d.end());
//删除并copy到输出流,会输出9,10,18
unique_copy(d.begin() ,d.end() ,std::ostream_iterator<int>(std::cout," "));
bool differenceOne(int ele1,int ele2) {return ele1 - 1 == ele2 ||  ele1 + 1 == ele2;
}
unique_copy(d.begin() ,d.end() ,std::ostream_iterator<int>(std::cout," "),differenceOne);//一个数比前一个数大一或者小一就删除
unique(begin1,end1,谓词) / unique_copy(begin1,end1,begin2,谓词)翻转
reverse(d.begin(), d.end());反转元素
reverse_copy(d.begin(), d.end(), std::ostream_iterator<int>(std::cout," "));//反转输出元素rotate(begin,pos,end) //pos到begin为单位,向前移动(旋转)
rotate_copy(begin,pos,end,begin2)排列组合,如果原始容器是正序排的 用next_permutation,否则用prev_permutation.
next_permutation() / prev_permutation()
vector<int> d{1,2,3};
while(next_permutation(d.begin(), d.end())) {for(auto &t : d) {cout << t << "t";}cout << endl;
}
random_shuffle(begin,end) //随机排序
//分区,返回两个区域之间的迭代器
partition()
partition(d.begin(),d.end(), bind2nd(modulus<int>(),2));//奇数放在左面,偶数放右面
stable_partition()//稳定分区,会保持原来的顺序排序  list容器必须用自带的sort()排序
sort(d.begin(),d.end()); 小到大排序
sort(d.begin(),d.end() ,greater<int>());大到小排序,可以自定义谓词vector<string> d{"1xx","4x3x","3xx","daxxs","dswe4w","2324214"};
sort(d.begin(),d.end(), lessLength);bool lessLength(string &s1, string &s2) {return s1.length() < s2.length();
}
稳定排序,满足谓词的条件下,保证原来的相对次序
stable_sort(d.begin(),d.end(), lessLength);
stable_sort(d.begin(),d.end());局部排序
partial_sort(begin,pos,end);
partial_sort(begin,pos,end,谓词);
局部排序并copy到另一个容器
partial_sort_copy(begin1,pos,begin2,end2) 
partial_sort_copy(begin1,pos,begin2,end2,谓词)第n个元素排序
该函数可以从某个序列中(默认按照升序排序规则)找到第 n 小的元素 K,
并将 K 移动到序列中第 n 的位置处,再处理一下,位于 K 之前的元素都比 K 小,
所有位于 K 之后的元素都比 K 大。
nth_element(begin,n-pos,end) 
nth_element(d.begin(), pos, d.end(), greater<int>());按照降序规则找第n大的元素k,
并将 K 移动到序列中第 n 的位置处,再处理一下,位于 K 之前的元素都比 K 大,
所有位于 K 之后的元素都比 K 小。
vector<int> d{1,5,2,8,39,7,200,9};
vector<int>::iterator pos = d.begin();
advance(pos, 3); 迭代器向后移动3次 相当于3次pos++;
nth_element(d.begin(), pos, d.end(), greater<int>());