#include 
#include 
using namespace std;//使用STL算法对vector容器排序
#include
void printVectorInt(vector &v)
{vector::iterator it=v.begin();for(;it!=v.end();it++){cout<<*it<<" ";}cout<vector v1;v1.push_back(20);v1.push_back(60);v1.push_back(50);v1.push_back(30);v1.push_back(40);v1.push_back(10);printVectorInt(v1);//排序算法sort(v1.begin(), v1.end());printVectorInt(v1);return 0;
}

#include 
#include 
using namespace std;
#include
class Person
{friend bool comparePerson(Person &ob1, Person &ob2);friend void printVectorPerson(vector &v);
private:int num;string name;float score;
public:Person(){}Person(int num,string name, float score){this->num = num;this->name = name;this->score = score;}
};
void printVectorPerson(vector &v)
{vector::iterator it=v.begin();for(;it!=v.end();it++){//*it==Personcout<<(*it).num<<" "<<(*it).name<<" "<<(*it).score <return ob1.num < ob2.num;
}int main()
{vector v1;v1.push_back(Person(100,"lucy", 77.7f));v1.push_back(Person(103,"bob", 77.7f));v1.push_back(Person(101,"tom", 77.7f));v1.push_back(Person(104,"德玛", 77.7f));v1.push_back(Person(105,"小法", 77.7f));printVectorPerson(v1);//对自定义类型的vector排序 需要指定排序规则sort(v1.begin(), v1.end(), comparePerson);printVectorPerson(v1);return 0;
}

deque 容器

deque 容器基本概念

Vector 容器是单向开口的连续内存空间，deque 则是一种双向开口的连续线性空间。所谓的双向开口，
意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector 容器也可以在头尾两端插入元素，
但是在其头部操作效率奇差，无法被接受

Deque 容器和 vector 容器最大的差异，一在于 deque 允许使用常数项时间对头端进行元素的插入和删
除操作。二在于 deque 没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段
新的空间并链接起来，换句话说，像vector 那样，”旧空间不足而重新配置一块更大空间，然后复制元
素，再释放旧空间”这样的事情在 deque 身上是不会发生的。也因此，deque 没有必须要提供所谓的空
间保留(reserve)功能. 虽然 deque 容器也提供了 Random Access Iterator,但是它的迭代器并不是普通
的指针，其复杂度和 vector 不是一个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该
尽可能的使用 vector，而不是deque。对 deque 进行的排序操作，为了最高效率，可将 deque 先完整
的复制到一个 vector 中，对 vector 容器进行排序，再复制回 deque

deque 容器实现原理

Deque 容器是连续的空间，至少逻辑上看来如此（物理上不连续，逻辑上连续），连续现行空间总是令我们联想到array 和vector,array 无法成长，vector 虽可成长却只能向尾端成长，而且其成长其实是一个假象，事实上(1) 申请更大空间 (2)原数据复制新空间 (3)释放原空间三步骤，如果不是 vector 每次配置新的空间时都留有余裕，其成长假象所带来的代价是非常昂贵的。 Deque 是由一段一段的定量的连续空间构成。一旦有必要在deque 前端或者尾端增加新的空间，便配置一段连续定量的空间，串接在deque 的头端或者尾端。

Deque 最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了
重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。 既然 deque 是分段连续内存空间，
那么就必须有中央控制，维持整体连续的假象，数据结构的设计及迭代器的前进后退操作颇为繁琐。
Deque 代码的实现远比 vector 或 list 都多得多。 Deque 采取一块所谓的map(注意，不是 STL 的 map
容器)作为主控，这里所谓的 map 是一小块连续的内存空间，其中每一个元素(此处成为一个结点)都是一
个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque 的存储空间的主体。

deque 常用 API

1、deque 构造函数

deque deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem);//构造函数将 n 个 elem 拷贝给本身。
deque(const deque &deq);//拷贝构造函数。

2、deque 赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将 n 个 elem 拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
swap(deq);// 将 deq 与本身的元素互换

3、deque 大小操作

deque.size();//返回容器中元素的个数
deque.empty();//判断容器是否为空
deque.resize(num);//重新指定容器的长度为 num,若容器变长，则以默认值填充新位置。如果容器变
短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为 num,若容器变长，则以 elem 值填充新位置,如
果容器变短，则末尾超出容器长度的元素被删除。

4、deque 双端插入和删除操作

push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据

5、deque 数据存取

at(idx);//返回索引 idx 所指的数据，如果 idx 越界，抛出 out_of_range。
operator[];//返回索引 idx 所指的数据，如果 idx 越界，不抛出异常，直接出错。
front();//返回第一个数据。
back();//返回最后一个数据

6、deque 插入操作

insert(pos,elem);//在 pos 位置插入一个 elem 元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在 pos 位置插入 n 个 elem 数据，无返回值。
insert(pos,beg,end);//在 pos 位置插入[beg,end)区间的数据，无返回值。

7、deque 删除操作

clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除 pos 位置的数据，返回下一个数据的位置。

stack容器

stack 容器基本概念

stack 是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，形式如图所示。stack 容器
允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取 stack 的其 他元素。换言之，stack 不允许有遍历行为。 有元素入栈的操作称为:push,将元素出 stack 的操作称为pop.

Stack 所有元素的进出都必须符合”先进后出”的条件，只有 stack 顶端的元素，才有机会被外界取用。
Stack 不提供遍历功能，也不提供迭代器。

stack常用API

1、stack 构造函数

stack stkT;//stack 采用模板类实现， stack 对象的默认构造形式：
stack(const stack &stk);//拷贝构造函数

2、stack 赋值操作

stack& operator=(const stack &stk);//重载等号操作符

3、stack 数据存取操作

push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素

4、stack 大小操作

empty();//判断堆栈是否为空
size();//返回堆栈的大小

queue 容器

queue 容器基本概念

Queue 是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口，queue容器允许从一端新
增元素，从另一端移除元素。

Queue 所有元素的进出都必须符合”先进先出”的条件，只有 queue 的顶端元素，才有机会被外界取用。
Queue 不提供遍历功能，也不提供迭代器。

queue常用API

queue queT;//queue 采用模板类实现，queue 对象的默认构造形式：
queue(const queue &que);//拷贝构造函数
push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();//返回最后一个元素
front();//返回第一个元素
queue& operator=(const queue &que);//重载等号操作符
empty();//判断队列是否为空
size();//返回队列的大小

list容器

list 容器基本概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接
次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每
个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相较于
vector 的连续线性空间，list 就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者
释放一个元素的空间。因此，list 对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的
元素插入或元素的移除，list 永远是常数时间。 List 和vector 是两个最常被使用的容器。 List 容器是一
个双向链表。

采用动态存储分配，不会造成内存浪费和溢出 链表执行插入和删除操作十分方便，修改指针即可，不需
要移动大量元素 链表灵活，但是空间和时间额外耗费较大。

list常用API

1、list 构造函数

list lstT;//list 采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将 n 个 elem 拷贝给本身。
list(const list &lst);//拷贝构造函数。

2、 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 值匹配的元素。

3、list 大小操作

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为 num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为 num，若容器变长，则以 elem 值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

4、list 赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将 n 个 elem 拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将 lst 与本身的元素互换。

5、list 数据的存取

front();//返回第一个元素。
back();//返回最后一个元素。

6、list 反转排序

reverse();//反转链表，比如 lst 包含 1,3,5 元素，运行此方法后，lst 就包含 5,3,1元素。
sort(); //list 排序

举例

#include 
#include 
#include 
using namespace std;
void printListInt(list &l)
{list::iterator it=l.begin();for(;it!=l.end();it++){cout<<*it<<" ";}cout<list l1;l1.push_back(10);l1.push_back(20);l1.push_back(30);l1.push_front(40);l1.push_front(50);l1.push_front(60);printListInt(l1);//60 50 40 10 20 30//list容器的迭代器是双向迭代器  不支持+2(随机访问迭代器支持)  支持++list::iterator it=l1.begin();//it+2;it++;it++;l1.insert(it, 3, 100);printListInt(l1);//60 50 100 100 100 40 10 20 30//STL提供的算法 只支持随机访问迭代器 而list是双向迭代器 所以sort不支持list//sort(l1.begin(), l1.end());l1.sort();printListInt(l1);//10 20 30 40 50 60 100 100 100l1.reverse();printListInt(l1);
}int main(int argc, char *argv[])
{test01();return 0;
}

set/multiset容器

set/multiset 容器基本概念

set 的特性是。所有元素都会根据元素的键值自动被排序，set 的元素即是键值又是实值。

set 不允许两个元素有相同的键值。
set容器的迭代器是只读迭代器，不允许修改键值，会破坏set的内存布局。
multiset 特性及用法和 set 完全相同，唯一的差别在于它允许键值重复。

set常用API

1、set 构造函数

set st;//set 默认构造函数：
mulitset mst; //multiset 默认构造函数:
set(const set &st);//拷贝构造函数

2、set 赋值操作

set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器

3、set 大小操作

size();//返回容器中元素的数目
empty();//判断容器是否为空

4、set 插入和删除操作

insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除 pos 迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为 elem 的元素。

5、set 查找操作

find(key);//查找键 key 是否存在,若存在，返回该键的元素的迭代器；若不存在，返回 set.end();
count(key);//查找键 key 的元素个数
lower_bound(keyElem);//返回第一个 key>=keyElem 元素的迭代器。
upper_bound(keyElem);//返回第一个 key>keyElem 元素的迭代器。
equal_range(keyElem);//返回容器中 key 与 keyElem 相等的上下限的两个迭代器

举例迭代器是只读迭代器，原因是采用平衡二叉树的方法管理数据

#include 
#include 
#include 
using namespace std;
#include
void printSetInt(set  &s)
{set::const_iterator it=s.begin();for(;it!=s.end();it++){cout<<*it<<" ";}cout<
public:bool operator()(int v1, int v2){return v1>v2;}
};void printSetInt(set  &s)
{//修改排序规则，仿函数既是函数又是类型，MyGreater类会自动生成对象，对象与小括号结合会触发重载函数set::const_iterator it=s.begin();for(;it!=s.end();it++){cout<<*it<<" ";}cout<//set s1;set s1;s1.insert(30);s1.insert(10);s1.insert(20);s1.insert(50);s1.insert(40);printSetInt(s1);}int main(int argc, char *argv[])
{test01();return 0;
}

set存放自定义数据必须修改排序规则

#include 
#include 
#include 
using namespace std;
#include
class MyGreaterPerson;
class Person
{friend class MyGreaterPerson;friend void printSetPerson(set &s);
private:int num;string name;float score;
public:Person(){}Person(int num, string name, float score){this->num = num;this->name = name;this->score = score;}};
class MyGreaterPerson
{
public:bool operator()(Person ob1, Person ob2){return ob1.num < ob2.num;}
};
void printSetPerson(set &s)
{set::const_iterator it=s.begin();for(;it!=s.end();it++){//*it==Personcout<<(*it).num<<" "<<(*it).name<<" "<<(*it).score<//set存放自定义数据必须修改排序set s;s.insert(Person(100,"lucy", 88.8f));s.insert(Person(103,"tom", 88.8f));s.insert(Person(105,"bob", 88.8f));s.insert(Person(104,"德玛", 88.8f));s.insert(Person(102,"小法", 88.8f));printSetPerson(s);}
void test04()
{set s1;s1.insert(10);s1.insert(30);s1.insert(50);s1.insert(70);s1.insert(90);printSetInt(s1);set::const_iterator ret;ret = s1.find(50);if(ret != s1.end()){cout<<"找到的结果为:"<<*ret<test02();return 0;
}

equal_range(keyElem);//返回容器中 key 与 keyElem 相等的上下限的两个迭代器
举例

#include 
#include 
#include 
#include
using namespace std;
void test05()
{set s1;s1.insert(10);s1.insert(30);s1.insert(50);s1.insert(70);s1.insert(90);set::const_iterator ret;ret = s1.lower_bound(50);if(ret!=s1.end()){cout<<"下限为:"<<*ret<cout<<"上限为:"<<*ret<::const_iterator , set::const_iterator> pa;pa = s1.equal_range(50);if(pa.first != s1.end()){cout<<"下限为:"<<*(pa.first)<cout<<"上限为:"<<*(pa.second)<test07();return 0;
}

对组（pair）

对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用 pair 的两个
公有属性 first 和 second 访问。 类模板：template struct pair. 如何创建对组?

//第一种方法创建一个对组
pair pair1(string("name"), 20);
cout << pair1.first << endl; //访问 pair 第一个值
cout << pair1.second << endl;//访问 pair 第二个值
//第二种
pair pair2 = make_pair("name", 30);
cout << pair2.first << endl;
cout << pair2.second << endl;
//pair=赋值
pair pair3 = pair2;
cout << pair3.first << endl;
cout << pair3.second << endl;

map/multimap 容器

map/multimap 基本概念

Map 的特性是，所有元素都会根据元素的键值自动排序。Map 所有的元素都是pair,同时拥有实值和键
值，pair 的第一元素被视为键值，第二元素被视为实值，map 不允许两个元素有相同的键值。 我们可
以通过 map 的迭代器改变 map 的键值吗？答案是不行，因为 map 的键值关系到 map 元素的排列规
则，任意改变 map键值将会严重破坏 map 组织。如果想要修改元素的实值，那么是可以的。 Map 和
list 拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在
操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。 Multimap 和 map 的操作类
似，唯一区别 multimap 键值可重复。Map 和 multimap 都是以红黑树为底层实现机制。

map容器：每个元素都是 键值-实值 成对存储，自动根据键值排序， 键值不能重复，不能修改。

map/multimap 常用 API

1、map 构造函数

map mapTT;//map 默认构造函数:
map(const map &mp);//拷贝构造函数

2、map 赋值操作

map& operator=(const map &mp);//重载等号操作符
swap(mp);//交换两个集合容器

3、 map 大小操作

size();//返回容器中元素的数目
empty();//判断容器是否为空

4、 map 插入数据元素操作

map.insert(...); //往容器插入元素，返回 pair
map mapStu;
// 第一种 通过 pair 的方式插入对象
mapStu.insert(pair(3, "小张"));
// 第二种 通过 pair 的方式插入对象
mapStu.inset(make_pair(-1, "校长"));
// 第三种 通过 value_type 的方式插入对象
mapStu.insert(map::value_type(1, "小李"));
// 第四种 通过数组的方式插入值mapStu[3] = "小刘";
mapStu[5] = "小王";

5、 map 删除操作

clear();//删除所有元素
erase(pos);//删除 pos 迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(keyElem);//删除容器中 key 为 keyElem 的对组。

6、map 查找操作

find(key);//查找键 key 是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回 map.end();
count(keyElem);//返回容器中 key 为 keyElem 的对组个数。对 map 来说，要么是 0，要么是 1。对 multimap 来说，值可能大于 1。
lower_bound(keyElem);//返回第一个 key>=keyElem 元素的迭代器。
upper_bound(keyElem);//返回第一个 key>keyElem 元素的迭代器。
equal_range(keyElem);//返回容器中 key 与 keyElem 相等的上下限的两个迭代器

举例：

#include 
#include 

//函数对象也称为（仿函数）
class Print
{
public:void operator()(char *str){cout<Print ob;ob("hello world");Print()("hello world");//匿名对象
}

#include
#include
//普通函数
bool greaterThan30(int value)
{return value>30;
}
class GreaterThan30
{
public://仿函数bool operator()(int value){return value>30;}
};
int main()
{vector v1;v1.push_back(10);v1.push_back(30);v1.push_back(50);v1.push_back(70);v1.push_back(90);//find_if条件查找vector::iterator ret;//普通函数提供策略 函数名//ret = find_if(v1.begin(), v1.end(), greaterThan30);//仿函数提供策略 类名称+（）ret = find_if(v1.begin(), v1.end(), GreaterThan30());if(ret != v1.end()){cout<<"寻找的结果:"<<*ret<

bool myGreaterInt(int v1, int v2)
{return v1>v2;
}
class MyGreaterInt
{
public:bool operator()(int v1, int v2){return v1>v2;}
};
int main()
{vector v1;v1.push_back(10);v1.push_back(50);v1.push_back(30);v1.push_back(90);v1.push_back(70);printVectorAll(v1);//sort(v1.begin(), v1.end(), myGreaterInt);sort(v1.begin(), v1.end(), MyGreaterInt());printVectorAll(v1);
}

template T plus//加法仿函数
template T minus//减法仿函数
template T multiplies//乘法仿函数
template T divides//除法仿函数
template T modulus//取模仿函数
template T negate//取反仿函数

template bool equal_to//等于
template bool not_equal_to//不等于
template bool greater//大于
template bool greater_equal//大于等于
template bool less//小于
template bool less_equal//小于等于

template bool logical_and//逻辑与
template bool logical_or//逻辑或
template bool logical_not//逻辑非

#include 
#include 
#include //引入
using namespace std;
void printVectorInt(vector &v)
{vector::iterator it=v.begin();for(;it!=v.end();it++){cout<<*it<<" ";}cout<vector v1;v1.push_back(10);v1.push_back(50);v1.push_back(30);v1.push_back(90);v1.push_back(70);printVectorInt(v1);sort(v1.begin(), v1.end(), greater());//类模板要指定参数类型，此时是创建匿名对象printVectorInt(v1);
}
void test03()
{vector v1;v1.push_back(10);v1.push_back(50);v1.push_back(30);v1.push_back(90);v1.push_back(70);vector::iterator  ret;//使用适配器绑定参数ret = find_if(v1.begin(), v1.end(), bind2nd(greater(),30));if(ret != v1.end()){cout<<*ret<test02();return 0;
}

#include 
#include 
#include 
using namespace std;
//第二步：公共继承binary_function   参数萃取
class printInt:public binary_function
{
public://第三步：整个函数加const修饰void operator()(int value, int tmp) const{cout<<"value="<vector v1;v1.push_back(10);v1.push_back(30);v1.push_back(50);v1.push_back(70);v1.push_back(90);//for_each 提取容器的每个元素//第一步bind2nd 或 bind1st//bind2nd将100绑定到第二个参数tmp行 容器的元素在value上for_each(v1.begin(), v1.end(), bind2nd(printInt(), 100) );cout<

class Data
{
public:int data;
public:Data(){}Data(int d){data = d;}void printInt(int tmp){cout<<"value="<vector v1;v1.push_back(Data(10));v1.push_back(Data(30));v1.push_back(Data(50));v1.push_back(Data(70));v1.push_back(Data(90));//for_each 提取容器的每个元素for_each(v1.begin(), v1.end(), bind2nd(mem_fun_ref(&Data::printInt),100) );cout<

int main()
{vector v1;v1.push_back(10);v1.push_back(40);v1.push_back(50);v1.push_back(20);v1.push_back(30);//lambda 表达式 c++11才支持//[]里面啥都不写 lambda不能识别 外部数据//[=] lambda能对 外部数据 读操作//[&] lambda能对 外部数据 读写操作for_each(v1.begin(), v1.end(), [&](int val){cout<()));for_each(v1.begin(), v1.end(), [&](int val){cout<

/*
遍历算法 遍历容器元素
@param beg 开始迭代器
@param end 结束迭代器
@param _callback 函数回调或者函数对象
@return 函数对象
*/for_each(iterator beg, iterator end, _callback);

/*
transform 算法 将指定容器区间元素搬运到另一容器中
注意 : transform 不会给目标容器分配内存，所以需要我们提前分配好内存
@param beg1 源容器开始迭代器
@param end1 源容器结束迭代器
@param beg2 目标容器开始迭代器
@param _cakkback 回调函数或者函数对象
@return 返回目标容器迭代器
*/
transform(iterator beg1, iterator end1, iterator beg2, _callback);

/*
find 算法 查找元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return 返回查找元素的位置
*/
find(iterator beg, iterator end, value);
//用迭代器会接返回值

/*
find_if 算法 条件查找
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词(返回 bool 类型的函数对象)
@return bool 查找返回 true 否则 false
*/find_if(iterator beg, iterator end, _callback);

/*
adjacent_find 算法 查找相邻重复元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param _callback 回调函数或者谓词(返回 bool 类型的函数对象)
@return 返回相邻元素的第一个位置的迭代器
*/
adjacent_find(iterator beg, iterator end, _callback);
//返回值用迭代器去接

/*
binary_search 算法 二分查找法
注意: 在无序序列中不可用
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return bool 查找返回 true 否则 false
*/
bool binary_search(iterator beg, iterator end, value);
//返回值是布尔值

/*
count 算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 回调函数或者谓词(返回 bool 类型的函数对象)
@return int 返回元素个数*/
count(iterator beg, iterator end, value);

/*
count_if 算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词(返回 bool 类型的函数对象)
return int 返回元素个数
*/
count_if(iterator beg, iterator end, _callback);

/*
merge 算法 容器元素合并，并存储到另一容器中，要先开辟第三个容器的空间
注意:两个容器必须是有序的，谁小谁先移动
@param beg1 容器 1 开始迭代器
@param end1 容器 1 结束迭代器
@param beg2 容器 2 开始迭代器
@param end2 容器 2 结束迭代器
@param dest 目标容器开始迭代器
*/
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

/*
sort 算法 容器元素排序
@param beg 容器 1 开始迭代器
@param end 容器 1 结束迭代器
@param _callback 回调函数或者谓词(返回 bool 类型的函数对象)
*/
sort(iterator beg, iterator end, _callback)

/*
random_shuffle 算法 对指定范围内的元素随机调整次序
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
random_shuffle(iterator beg, iterator end);

/*
reverse 算法 反转指定范围的元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
reverse(iterator beg, iterator end)

/*
copy 算法 将容器内指定范围的元素拷贝到另一容器中
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param dest 目标起始迭代器
*/
copy(iterator beg, iterator end, iterator dest)

/*
replace 算法 将容器内指定范围的旧元素修改为新元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param oldvalue 旧元素
@param oldvalue 新元素
*/
replace(iterator beg, iterator end, oldvalue, newvale)

/*
replace_if 算法 将容器内指定范围满足条件的元素替换为新元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 函数回调或者谓词(返回 Bool 类型的函数对象)
@param oldvalue 新元素
*/
replace_if(iterator beg, iterator end, _callback, newvalue)

/*
swap 算法 互换两个容器的元素
@param c1 容器 1
@param c2 容器 2
*/
swap(container c1, container c2)

/*
accumulate 算法 计算容器元素累计总和
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 累加值
*/
accumulate(iterator beg, iterator end, value)

/*
fill 算法 向容器中添加元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value t 填充元素
*/
fill(iterator beg, iterator end, value)

/*
set_intersection 算法 求两个 set 集合的交集
注意:两个集合必须是有序序列
@param beg1 容器 1 开始迭代器
@param end1 容器 1 结束迭代器
@param beg2 容器 2 开始迭代器
@param end2 容器 2 结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2,iterator dest)

/*
set_union 算法 求两个 set 集合的并集
注意:两个集合必须是有序序列
@param beg1 容器 1 开始迭代器
@param end1 容器 1 结束迭代器
@param beg2 容器 2 开始迭代器
@param end2 容器 2 结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)

/*
set_difference 算法 求两个 set 集合的差集
注意:两个集合必须是有序序列
@param beg1 容器 1 开始迭代器
@param end1 容器 1 结束迭代器
@param beg2 容器 2 开始迭代器
@param end2 容器 2 结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2,iterator dest)