C++提高笔记（二：容器和常用算法部分）
39、vector容器
功能：
vector数据结构和数组非常相似，也称为单端数组
vector与普通数组区别：
不同之处在于数组是静态空间，而vector可以动态扩展
动态扩展：
（1）并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。
（2）vector容器的迭代器是支持随机访问的迭代器。
vector<int> v;//创建一个vector容器
v.begin();//指向开始的指针 或者是v.rend();
v.end();//指向末尾的指针 或者是v.begin();
v.insert();//插入
40、vector构造函数
功能描述：创建vector容器
函数原型：
（1）vector<T> v; //采用模板实现类实现，默认构造函数
（2）vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
（3）vector(n, elem); //构造函数将n个elem拷贝给本身。
（4）vector(const vector &vec); //拷贝构造函数。
例子：
void printVector(vector<int> &v1) {//将vector作为函数的形参
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
cout << *it << endl;
}
}
void test() {
vector<int> v;
v.push_back(12);
v.push_back(123);
v.push_back(1234);
v.push_back(12345);
vector<int> v2(v.begin(), v.end());
printVector(v2);
printVector(v);
}
41、 vector赋值操作
功能描述：给vector容器进行赋值
函数原型：
（1）vector& operator=(const vector &vec);//重载等号操作符
（2）assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。注意，这里是赋值，不是构造。
（3）assign(n, elem); //将n个elem拷贝赋值给本身。
总结： vector赋值方式比较简单，使用operator=，或者assign都可以
42、vector容量和大小
功能描述：对vector容器的容量和大小操作
函数原型：
（1）empty(); //判断容器是否为空
（2）capacity(); //容器的容量
（3）size(); //返回容器中元素的个数， 注：容量一般是大于等于大小的。
（4）resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值0填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
（5）resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除
总结：
判断是否为空 — empty
返回元素个数 — size
返回容器容量 — capacity
重新指定大小 — resize
42、vector插入和删除
功能描述：对vector容器进行插入、删除操作
函数原型：
push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele，注意是迭代器
insert(const_iterator pos, int count, ele);//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向的元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
clear(); //删除容器中所有元素
例子：
void printVector(vector<int> &v1) {
for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
cout << *it<<" ";
}
cout << endl;
}
void test() {
vector<int> v1;
v1.push_back(10);//尾插法
v1.push_back(20);
printVector(v1);
v1.pop_back();//尾删
printVector(v1);
v1.push_back(20);
v1.push_back(30);
v1.insert(v1.begin() + 1, 1000);//插入
printVector(v1);
v1.erase(v1.begin() + 1);//删除迭代器的位置,注意是迭代器
printVector(v1);
v1.erase(v1.begin(), v1.end());//删除所有的元素,等价于 v1.clear()
printVector(v1);
}
总结：
尾插 — push_back
尾删 — pop_back
插入 — insert (位置迭代器)
删除 — erase （位置迭代器）
清空 — clear
43、vector数据存取
功能描述：对vector中的数据的存取操作
函数原型：
at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素
总结：
除了用迭代器获取vector容器中元素，[ ]和at也可以
front返回容器第一个元素
back返回容器最后一个元素
44、vector互换容器
功能描述：实现两个容器内元素进行互换
函数原型：
swap(vec); // 将vec与本身的元素互换
实际用途：swap可以使两个容器互换，可以达到实用的收缩内存效果
例子：
vector<int> v1;
for (int i = 0; i < 100000;i++) {
v1.push_back(i+1);
}
cout << v1.capacity() << " "<< v1.size() << endl;
v1.resize(3);//容量不会变，但是size会变为3
cout << v1.capacity() << " " << v1.size() << endl;
//巧用swap
vector<int>(v1).swap(v1);//容量和大小都会变，注释：vector<int>(v)表示匿名对象，使用v来初始化匿名对象（拷贝函数），再使用swap交换
cout << v1.capacity() << " " << v1.size() << endl;
45、vector预留空间
功能描述：减少vector在动态扩展容量时的扩展次数
函数原型：
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
例子：
vector<int> v;
v.reserve(10000);//预留空间
int* p = NULL;
int num = 0;//统计开辟次数
for (int i = 0; i < 10000;i++) {
v.push_back(i);
if (p != &v[0]) {
p = &v[0];
num += 1;
}
}
cout << num << endl;//30次， reserve 之后就变为了1
总结：如果数据量较大，可以一开始利用reserve预留空间
46、deque容器（deque：双端容器）
deque容器基本概念
功能：
双端数组，可以对头端进行插入删除操作
deque与vector区别：
vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关
eque内部工作原理:
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
deque容器的迭代器也是支持随机访问的
47、deque构造函数
功能描述：deque容器构造
函数原型：
deque<T> deqT; //默认构造形式
deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq); //拷贝构造函数
例子：
void printDeque(const deque<int> &v1) {// 添加const 容器变为只读状态
for (deque<int>::const_iterator it = v1.begin(); it != v1.end(); it++) {//需要将iterator变为const_iterator
//*it = 100;//容器里的内容就不可以修改了
cout << *it<<" ";
}
cout << endl;
}
void test() {
deque<int> d;
for (int i = 0; i < 10; i++) {
d.push_back(i+1);
}
printDeque(d);
}
总结：deque容器和vector容器的构造方式几乎一致，灵活使用即可
48、deque赋值操作
功能描述：给deque容器进行赋值
函数原型：
deque& operator=(const deque &deq); //重载等号操作符
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem); //将n个elem拷贝赋值给本身。
总结：deque赋值操作也与vector相同，需熟练掌握
49、deque大小操作
功能描述：对deque容器的大小进行操作
函数原型：
deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
注意：deque没有容量的概念，因为它的容量可以变化
50、deque 插入和删除
功能描述：向deque容器中插入和删除数据
函数原型：
两端插入操作：
push_back(elem); //在容器尾部添加一个数据
push_front(elem); //在容器头部插入一个数据
pop_back(); //删除容器最后一个数据
pop_front(); //删除容器第一个数据
指定位置操作：
insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。
clear(); //清空容器的所有数据
erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos); //删除pos位置的数据，返回下一个数据的位置。
总结：
插入和删除提供的位置是迭代器！
尾插 — push_back
尾删 — pop_back
头插 — push_front
头删 — pop_front
51、deque 数据存取
功能描述：对deque 中的数据的存取操作
函数原型：
at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素
52、deque 排序（需要添加头文件 # include<a;gorithms>)
功能描述：利用算法实现对deque容器进行排序(默认升序)
算法：
sort(iterator beg, iterator end) //对beg和end区间内元素进行排序
53、stack容器（符合先进后出的数据结构）
概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为
栈中进入数据称为 — 入栈 push
栈中弹出数据称为 — 出栈 pop
54、stack 常用接口
功能描述：栈容器常用的对外接口
构造函数：
stack<T> stk; //stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数
赋值操作：
stack& operator=(const stack &stk); //重载等号操作符
数据存取：
push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素
大小操作：
empty(); //判断堆栈是否为空
size(); //返回栈的大小
55、queue 基本概念
概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口
队列容器允许从一端新增元素，从另一端移除元素
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为
队列中进数据称为 — 入队 push
队列中出数据称为 — 出队 pop
56、常用接口：
功能描述：栈容器常用的对外接口
构造函数：
queue<T> que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数
赋值操作：
queue& operator=(const queue &que); //重载等号操作符
数据存取：
push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素
大小操作：
empty(); //判断堆栈是否为空
size(); //返回栈的大小
注意：只有队头和队尾才能被外界访问，所以不许允遍历行为。
总结：
入队 — push
出队 — pop
返回队头元素 — front
返回队尾元素 — back
判断队是否为空 — empty
返回队列大小 — size
57、list基本概念
功能：将数据进行链式存储
链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
链表的组成：链表由一系列结点组
STL中的链表是一个双向循环链表
双向：每一个节点既记录了上一个节点的信息，又记录了下一个节点的信息。
循环：最后一个节点记录的是第一个节点的位置。
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于*双向迭代器*
list的优点：
采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
list的缺点：
链表灵活，但是空间(指针域) 和 时间（遍历）额外耗费较大
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。
总结：STL中List和vector是两个最常被使用的容器，各有优缺点
58、list构造函数
功能描述：创建list容器
函数原型：
list<T> lst; //list采用采用模板类实现,对象的默认构造形式：
list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem); //构造函数将n个elem拷贝给本身。
list(const list &lst); //拷贝构造函数。
59、list 赋值和交换
功能描述：给list容器进行赋值，以及交换list容器
函数原型：
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem); //将n个elem拷贝赋值给本身。
list& operator=(const list &lst); //重载等号操作符
swap(lst); //将lst与本身的元素互换。
60、list 大小操作
功能描述：对list容器的大小进行操作
函数原型：
size(); //返回容器中元素的个数
empty(); //判断容器是否为空
resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
**************************************这里需要熟练*************************************
61、list 插入和删除
功能描述：对list容器进行数据的插入和删除
函数原型：
push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。
62、list 数据存取
功能描述：对list容器中数据进行存取
函数原型：
front(); //返回第一个元素。
back(); //返回最后一个元素。
总结：
list容器中不可以通过[ ]或者at方式访问数据（list的迭代器不支持随机访问 && 是list不是连续的空间）
返回第一个元素 — front
返回最后一个元素 — back
63、list 反转和排序
功能描述：将容器中的元素反转，以及将容器中的数据进行排序
函数原型：
reverse(); //反转链表
sort(); //链表排序，默认的排序规则是从小到大。
如果想从大到小的话，需要写一个函数：
bool myCompare(int v1, int v2) {
//降序，就让v1>v2, 就return v1>v2
return v1 > v2;
}
L.sort(myCompare);
得到的结果就是降序的！
注意：不支持随机访问的容器，不能用标准的algorithm，（比如list就不可以）。但是不支持 随机访问的容器内部会提供对应的一些算法。
例子：
bool comparePerson(Person &p1, Person &p2) {
//按照年龄升序
if (p1.m_Age == p2.m_Age) {// 添加排序规则
return p1.m_H < p2.m_H;
}
return p1.m_Age < p2.m_Age;
}
void test() {
list<Person> L;//创建一个容器
Person p1("刘备", 35, 175);// name, age, height
Person p2("曹操", 45, 180);
Person p3("孙权", 40, 170);
Person p4("赵云", 25, 190);
Person p5("张飞", 35, 160);
Person p6("关羽", 35, 200);
L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
L.push_back(p6);
printList(L);
//排序
cout << "------------------after sort---------------------" << endl;
//必须要有一个排序规则(回调函数)
L.sort(comparePerson);
printList(L);
}
总结：
对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序
高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂
64、set/ multiset 容器
3.8.1 set基本概念
简介：所有元素都会在插入时自动被排序
本质：
set/multiset属于关联式容器，底层结构是用二叉树实现。
set和multiset区别：
set不允许容器中有重复的元素
multiset允许容器中有重复的元素
65、set构造和赋值
功能描述：创建set容器以及赋值
构造：
set<T> st; //默认构造函数：
set(const set &st); //拷贝构造函数
赋值：
set& operator=(const set &st); //重载等号操作符
例子：
void printSet(const set<int>& s) {
for (set<int>::const_iterator it = s.begin(); it != s.end(); it++) {
cout << *it<<" ";
}
cout << endl;
}
void test() {
set<int> s;
s.insert(10);//只有insert的方式
s.insert(20);
s.insert(40);
s.insert(30);
s.insert(2);
printSet(s);
}
set特点：所有元素在插入的时候自动被排序，不允许插入重复值（会自动被删除）
66、set大小和交换（因为不允许有重复的值，所以不能重新指定大小）
功能描述：统计set容器大小以及交换set容器
函数原型：
size(); //返回容器中元素的数目
empty(); //判断容器是否为空
swap(st); //交换两个集合容器
67、set插入和删除
功能描述：set容器进行插入数据和删除数据
函数原型：
insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem); //删除容器中值为elem的元素。
68、set查找和统计
功能描述：对set容器进行查找数据以及统计数据
函数原型：
find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数
69、set和multiset区别
学习目标：掌握set和multiset的区别
区别：
set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入是否成功
注意：通过对组pair<set<int>::iterator , bool> ret = s.insert();来检查是否插入成功
multiset不会检测数据，因此可以插入重复数据
70、pair对组创建
功能描述：成对出现的数据，利用对组可以返回两个数据
两种创建方式：
pair<type, type> p ( value1, value2 );
pair<type, type> p = make_pair( value1, value2 );
例子：
void test() {
pair<string, int> p("Tom", 32);
cout << "Name " << p.first << endl;
cout << "Age " << p.second << endl;
pair<string, int> p1 = make_pair("Jerry", 64);
cout << "Name " << p1.first << endl;
cout << "Age " << p1.second << endl;
}
71、set容器排序
学习目标：set容器默认排序规则为从小到大，掌握如何改变排序规则
主要技术点：
利用仿函数，可以改变排序规则
仿函数：重载了函数调用符() 比如bool operator()(int v1, int v2){};
注意：VS2019在重载()的时候需要在前面加const，否则会报错。
一 set存放内置数据类型:
class MyCompare {//这是仿函数，本质上是类
public:
bool operator()(int v1,int v2)const { // 也不能使用引用类型调用，加const变为常函数
return v1 > v2;
}
};
void printSet(const set<int, MyCompare>& s) {
for (set<int,MyCompare>::const_iterator it = s.begin(); it != s.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test() {
set<int, MyCompare> s1 = {10,20,30,50,40};
printSet(s1);
}
二 set存放自定义数据类型：
class MyCompare {//这是仿函数，本质上是类
public:
bool operator()(Person v1,Person v2)const { // 也不能使用引用类型调用，加const变为常函数
return v1.m_Age > v2.m_Age;
}
};
void printSet(const set<Person, MyCompare>& s) {
for (set<Person,MyCompare>::const_iterator it = s.begin(); it != s.end(); it++) {
cout << (*it).m_Name << " " << (*it).m_Age << ". " << endl;;
}
}
void test() {
Person p1("刘备", 24);
Person p2("张飞", 254);
Person p3("关羽", 42);
Person p4("赵云", 12);
set<Person, MyCompare> s = { p1,p2,p3,p4 };
printSet(s);
总结：仿函数和直接写cmp函数其实是一样的原理，只是重载了（），而且作用域都是全局。所以在类里面直接写cmp的时候需要添加static关键字，放到静态区。在写仿函数的时候，不可以使用引用调用，具体原因目前还不是很清楚（要用的话，需要在前面再加const，貌似也是对VS2019来说的），另外，在VS2019里面，还需要添加const才可以，比如bool operator()(int v1,int v2)const{} ，否则也会报错。
********************************************************************************
72、map基本概念（高性能、高效率）
简介：
map中所有元素都是pair
pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
所有元素都会根据元素的键值自动排序
本质：
map/multimap属于关联式容器，底层结构是用二叉树实现。
优点：
可以根据key值快速找到value值
map和multimap区别：
map不允许容器中有重复key值元素
multimap允许容器中有重复key值元素
73、 map构造和赋值
功能描述：对map容器进行构造和赋值操作
函数原型：
构造：
map<T1, T2> mp; //map默认构造函数:
map(const map &mp); //拷贝构造函数
赋值：
map& operator=(const map &mp); //重载等号操作符
例子：
map<int, int> m;
m.insert(pair<int, int>(1, 10));//匿名对组
m.insert(pair<int, int>(2, 3230));
m.insert(pair<int, int>(7, 23));
cout << m[7] << endl;//输出7
总结：map中所有元素都是成对出现，插入数据时候要使用对组
74、map大小和交换
功能描述：统计map容器大小以及交换map容器
函数原型：
size(); //返回容器中元素的数目
empty(); //判断容器是否为空
swap(st); //交换两个集合容器
75、map插入和删除
功能描述：map容器进行插入数据和删除数据
函数原型：
insert(elem); //在容器中插入元素。注意，插入的是对组。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(key); //删除容器中值为key的元素。
76、map查找和统计
功能描述：对map容器进行查找数据以及统计数据
函数原型：
find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数 只是在multimap里面有效，在map里面永远是1.
例子：
map<int, int> m;
m.insert(pair<int, int>(1, 10));//匿名对组
m.insert(pair<int, int>(2, 3230));
m.insert(pair<int, int>(7, 243));
m.insert(pair<int, int>(34, 233));
m.insert(pair<int, int>(5, 253));
m.insert(pair<int, int>(4, 237));
map<int, int>::iterator x = m.find(7);
if (x != m.end()) {
cout << "Find it!" << endl;
}
77、map容器排序
学习目标：map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则
注意，这里的默认指的是不调用sort，直接就是排好了的。
主要技术点:
利用仿函数，可以改变排序规则
*****************************************************************************************
78、函数对象（仿函数）
函数对象概念
概念：
重载函数调用操作符的类，其对象常称为函数对象
函数对象使用重载的()时，行为类似函数调用，也叫仿函数
本质：
函数对象(仿函数)是一个类，不是一个函数
79、函数对象使用
特点：
函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递
例子：
class MyAdd {
public:
int operator()(int a, int b) {
return a + b;
}
};
void test() {
MyAdd add;//也是需要先创建对象的，只是在sort里面好像不需要创建对象
int a = 9;
int b = 6;
cout << add(a, b) << endl;
}
总结：仿函数写法非常灵活，可以作为参数进行传递
80、谓词
概念：
返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词
例子（一元谓词）：
class GF {
public:
bool operator()(int val) {
return val > 5;
}
};
void test() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i + 1);
}
//查找有无大于5的数字
vector<int>::iterator it = find_if(v.begin(),v.end(),GF());//最后传递一个匿名的函数对象
if (it == v.end()) {
cout << "没有找到" << endl;
}
else {
cout << "找到了：" << *it << endl;
}
}
二元谓词（那个cmp里面的比较大小sort的排序规则）：
**************************************************************************
81、内建函数对象
概念：STL内建了一些函数对象
分类:
算术仿函数
关系仿函数
逻辑仿函数
用法：
这些仿函数所产生的对象，用法和一般函数完全相同
使用内建函数对象，需要引入头文件 #include<functional>
82、算术仿函数
功能描述：实现四则运算
其中negate是一元运算，其他都是二元运算
仿函数原型：
template<class T> T plus<T> //加法仿函数
template<class T> T minus<T> //减法仿函数
template<class T> T multiplies<T> //乘法仿函数
template<class T> T divides<T> //除法仿函数
template<class T> T modulus<T> //取模仿函数
template<class T> T negate<T> //取反仿函数
例子：
void test() {
negate<int> n;
plus<int> p;
cout << n(50) << endl;
cout << p(10, 20) << endl;
}
总结：使用内建函数对象时，需要引入头文件 #include <functional>
83、关系仿函数
功能描述：实现关系对比
仿函数原型：
template<class T> bool equal_to<T> //等于
template<class T> bool not_equal_to<T> //不等于
template<class T> bool greater<T> //大于
template<class T> bool greater_equal<T> //大于等于
template<class T> bool less<T> //小于
template<class T> bool less_equal<T> //小于等于
例子：
void test() {
vector<int> a = { 9, 12, 32,34,1,2,3 };
cout << endl;
sort(a.begin(), a.end(), greater_equal<int>());
for (vector<int>::iterator it = a.begin(); it != a.end(); it++) {
cout << *it <<" ";
}
cout << endl;
}
84、逻辑仿函数
功能描述：实现逻辑运算
函数原型：
template<class T> bool logical_and<T> //逻辑与
template<class T> bool logical_or<T> //逻辑或
template<class T> bool logical_not<T> //逻辑非
例子：
void test() {
vector<bool> v;
v.push_back(true);
v.push_back(false);
v.push_back(true);
v.push_back(false);
//利用逻辑非，将容器v搬运到容器v2中，并执行取反操作
vector<bool> v2(v.size());
transform(v.begin(), v.end(), v2.begin(),logical_not<int>());
for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
85、常用算法
概述:算法主要是由头文件<algorithm> <functional> <numeric>组成。
<algorithm>是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等
<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数
<functional>定义了一些模板类,用以声明函数对象。
86、常用遍历算法
学习目标：掌握常用的遍历算法
算法简介：
for_each //遍历容器
transform //搬运容器到另一个容器中
87、for_each
功能描述：实现遍历容器
函数原型：
for_each(iterator beg, iterator end, _func);
// 遍历算法 遍历容器元素
// beg 开始迭代器
// end 结束迭代器
// _func 函数或者函数对象
例子：
class print02 { //仿函数
public:
void operator()(int val) {
cout << val << " ";
}
};
void print(int val) { //普通函数：注意，在类外
cout << val << " ";
}
void test() {
vector<int> v = {1,2,1,323,12,32};
for_each(v.begin(), v.end(),print); // 普通函数
cout << endl;
for_each(v.begin(), v.end(), print02());//仿函数（使用匿名对象）
cout << endl;
}
88、transform
功能描述：搬运容器到另一个容器中
函数原型：
transform(iterator beg1, iterator end1, iterator beg2, _func);
//beg1 源容器开始迭代器
//end1 源容器结束迭代器
//beg2 目标容器开始迭代器
//_func 函数或者函数对象（搬运期间可以进行操作）
89、常用查找算法
学习目标：掌握常用的查找算法
算法简介：
find //查找元素
find_if //按条件查找元素
adjacent_find //查找相邻重复元素
binary_search //二分查找法
count //统计元素个数
count_if //按条件统计元素个数
89、find
功能描述：查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
函数原型：
find(iterator beg, iterator end, value);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素
90、find_if
功能描述：按条件查找元素
函数原型：
find_if(iterator beg, iterator end, _Pred);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 函数或者谓词（返回bool类型的仿函数）
注意：可以对自定义类型进行操作。
总结：find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略
91、adjacent_find
功能描述：查找相邻重复元素
函数原型：
adjacent_find(iterator beg, iterator end);
// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器
// beg 开始迭代器
// end 结束迭代器
92、binary_search（二分法查找：非常快，但是必须要是有序数列）
功能描述：查找指定元素是否存在
函数原型：
bool binary_search(iterator beg, iterator end, value);
// 查找指定的元素，查到 返回true 否则false
// 注意: 在无序序列中不可用
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素
93、 count
功能描述：统计元素个数
函数原型：
count(iterator beg, iterator end, value);
// 统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// value 统计的元素
总结： 统计自定义数据类型时候，需要配合重载 operator==
一个例子：
class Person {
public:
Person(string name, int age) {
m_Name = name;
m_Age = age;
}
bool operator==(const Person &p2) { //重载运算符 == 需要加const 变为只读模式，底层代码需要添加 ，这里说的底层是指后面的count函数。
if (m_Name == p2.m_Name && m_Age == p2.m_Age) {
return true;
}
else {
return false;
}
}
string m_Name;
int m_Age;
};
void test() {
Person p1("Tom", 12);
Person p2("Jerry", 23);
Person p3("Tom", 12);
Person p4("Tom", 12);
vector<Person> v;
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
Person s("Tom", 12);
cout << count(v.begin(), v.end(),s) << endl;;
}
94、count_if
功能描述：按条件统计元素个数
函数原型：
count_if(iterator beg, iterator end, _Pred);
// 按条件统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词
************************常用拍排序算法************************************
95、常用排序算法
学习目标：掌握常用的排序算法
算法简介：
sort //对容器内元素进行排序
random_shuffle //洗牌 指定范围内的元素随机调整次序
merge // 容器元素合并，并存储到另一容器中
reverse // 反转指定范围的元素
96、sort
功能描述：对容器内元素进行排序
函数原型：
sort(iterator beg, iterator end, _Pred);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词
97、random_shuffle
功能描述：洗牌 指定范围内的元素随机调整次序
函数原型：
random_shuffle(iterator beg, iterator end);
// 指定范围内的元素随机调整次序
// beg 开始迭代器
// end 结束迭代器
例子：
class MyPrint {
public:
void operator()(int val) {
cout << val << " ";
}
};
void test() {
vector<int> v;
for (int i = 0; i < 20; i++) {
v.push_back(i + 1);
}
for_each(v.begin(), v.end(), MyPrint());//输出
cout << endl;
random_shuffle(v.begin(), v.end());//打乱顺序
for_each(v.begin(), v.end(), MyPrint());
cout << endl;
}
**总结：**random_shuffle洗牌算法比较实用，使用时记得加随机数种子
srand((unsigned int)time(NULL))
98、merge
功能描述：个容器元素合并，并存储到另一容器中
函数原型：
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 容器元素合并，并存储到另一容器中
// 注意: 两个容器必须是有序的
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
**总结：**merge合并的两个容器必须的有序序列
99、reverse
功能描述：将容器内元素进行反转
函数原型：
reverse(iterator beg, iterator end);
// 反转指定范围的元素
// beg 开始迭代器
// end 结束迭代器
**总结：**reverse反转区间内元素，面试题可能涉及到
100、常用拷贝和替换算法
学习目标：掌握常用的拷贝和替换算法
算法简介：
copy // 容器内指定范围的元素拷贝到另一容器中
replace // 将容器内指定范围的旧元素修改为新元素
replace_if // 容器内指定范围满足条件的元素替换为新元素
swap // 互换两个容器的元素
101、copy
功能描述：容器内指定范围的元素拷贝到另一容器中
函数原型：
copy(iterator beg, iterator end, iterator dest);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// dest 目标起始迭代器
**总结：**利用copy算法在拷贝时，目标容器记得提前开辟空间
102、replace
功能描述：容器内指定范围的旧元素修改为新元素
函数原型：
replace(iterator beg, iterator end, oldvalue, newvalue);
// 将区间内旧元素 替换成 新元素
// beg 开始迭代器
// end 结束迭代器
// oldvalue 旧元素
// newvalue 新元素
103、replace_if
功能描述: 将区间内满足条件的元素，替换成指定元素
函数原型：
replace_if(iterator beg, iterator end, _pred, newvalue);
// 按条件替换元素，满足条件的替换成指定元素
// beg 开始迭代器
// end 结束迭代器
// _pred 谓词
// newvalue 替换的新元素
104、swap
功能描述：互换两个容器的元素
函数原型：
swap(container c1, container c2);
// 互换两个容器的元素
// c1容器1
// c2容器2
**总结：**swap交换容器时，注意交换的容器要同种类型
105、常用算术生成算法
学习目标：掌握常用的算术生成算法
注意：
算术生成算法属于小型算法，使用时包含的头文件为 #include <numeric>
算法简介：
accumulate // 计算容器元素累计总和
fill // 向容器中添加元素
106、accumulate
功能描述：计算区间内 容器元素累计总和
函数原型：
accumulate(iterator beg, iterator end, value);
// 计算容器元素累计总和
// beg 开始迭代器
// end 结束迭代器
// value 起始值 起始的累加值
**总结：**accumulate使用时头文件注意是 numeric，这个算法很实用
107、 fill
功能描述：向容器中填充指定的元素
函数原型：
fill(iterator beg, iterator end, value);
// 向容器中填充元素
// beg 开始迭代器
// end 结束迭代器
// value 填充的值
**总结：**利用fill可以将容器区间内元素填充为 指定的值
108、常用集合算法
学习目标：掌握常用的集合算法
算法简介：
set_intersection // 求两个容器的交集
set_union // 求两个容器的并集
set_difference // 求两个容器的差集
109、set_intersection（交集）
功能描述：求两个容器的交集
函数原型：
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的交集
//***** 注意:两个集合必须是有序序列*****
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
总结：
求交集的两个集合必须的有序序列
目标容器开辟空间需要从两个容器中取小值
set_intersection返回值既是交集中最后一个元素的位置
110、 set_union（并集）
功能描述：求两个集合的并集
函数原型：
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的并集
// 注意:两个集合必须是有序序列
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
总结：
求并集的两个集合必须的有序序列
目标容器开辟空间需要两个容器相加
set_union返回值既是并集中最后一个元素的位置
111、set_difference
功能描述：求两个集合的差集
函数原型：
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的差集
// 注意:两个集合必须是有序序列
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
总结：
求差集的两个集合必须的有序序列
目标容器开辟空间需要从两个容器取较大值
void test01()
{
vector v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i + 1);
}
vector v2;
v2.resize(v1.size());
copy(v1.begin(), v1.end(), v2.begin());
for_each(v2.begin(), v2.end(), myPrint());
cout << endl;
}