C++之初识STL

#include<vector>
#include<algorithm>    //标准算法头文件
void myPrin(int val)
{
    cout<<val;
}
...
    //创建一个vector容器，数组
    vector<int> v;
    //向容器中插入元素
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    vector<int>::iterator itBegin = v.begin();    //起始迭代器，指向容器的第一个位置
    vector<int>::iterator itEnd = v.end();    //结束迭代器，指向容器中最后一个元素的下一个位置
    //第一种遍历
    while(itBegin!=itEnd)
    {
        cout<<*itBegin;
        itBegin++;
    }
    //第二种遍历
    for(vector<int>::iterator it=v.begin();it!=v,end();it++)
        cout<<*it<<;
    //第三种遍历，利用STL提供的算法遍历
    for_each(v.begin(),v.end(),myPrint);

STL常用容器

1.string容器

本质：

string是一个类

string和char*区别:

char*是一个指针
string是一个类，类内部封装了char*，管理这个字符串，是一个char"型的容器。

string构造函数

#include<string>
...
string();    //创建一个空字符串
string(const char* s)    //使用字符串s初始化
string(const string& s)    //使用一个string对象初始化另一个string对象
string（int n,char c)    //使用n个字符c初始化

string赋值操作

功能描述：给string字符串进行复制

#include<string>
....
string& operator=(const char* s);        //char*类型字符串 赋值给当前字符串
string& operator=(const string &s);      //把字符串s赋给当前字符串
string& operator=(char c);               //字符赋值给当前的字符串
string& assign(const char *s);           //把字符串s贼给当前的字符串
string& assign(const char *s,int n);     //把字符串s的前n个字符照给当前的字符电
string& assign(const string &s);         //把字符串s赋给当前字符串
string& assign(int n,char c);            //用n个字符c赚给当前字符串

string的拼接

功能描述：是现在字符串末尾拼接字符串

#include<string>
...
string& operator+=(const char* str);             //重载+=操作符
string& operator+=(const char c);                //重载+=操作符
string& operator+=(const string& str);           //重载+=操作符
string& append(const char *s);                   //把字符串s连接到当前字符串结尾
string& append(const char *s, int n);            //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s);                 //同operator+=(const string& str)
string& append(const string &s，int pos,int n);  //字符串s中从pos开始的n个字符连接到字符串结尾

string查找和替换

功能描述：

1.查找：查找指定字符串是否存在

2.替换：在指定的位置替换字符串

#include<string>
...
int find(const string& str,int pos=0) const;            //查找str第一次出现位置,从pos开始查找
int find(const char* s,int pos=0) const;                //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos,int n) const;           //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos =0) const;               //查找字符c第一次出现位置
int rfind(const string& str,int pos=npos) const;        //查找str最后一次位置,从pos开始查找
int rfind(const char* s,int pos=npos) const;            //查找s最后一次出现位置,从pos开始查找
int rfind(const char* s,int pos,int n) const;           //从pos查找s的前n个字符最后一次位置
int rfind(const char c,int pos=0) const;                //查找字符C最后一次出现位置
string& replace(int pos,int n, const string& str);      //替换从pos开始n个字符为字符串str
string& replace(int pos,int n,const char* s);           //替换从pos开始的n个字符为字符串s

string字符串比较

功能：字符串之间的比较

= 返回 0

> 返回 1

< 返回 -1

#include<string>
...
int compare(const string &s) const;    //与字符串s比较
int compare(const char *s) const;      //与字符串s比较

string字符存取

#include<string>
...
char& operator[](int n);    //通过[]方式取字符
char& at(int n);            //通过at方法获取字符

string插入和删除

功能描述：对string字符串进行插入和删除字符操作

#include<string>
...
string& insert(int pos,const char* s);        //插入字符串
string& insert(int pos,const string& str);    //插入字符串
string& insert(int pos,int n, char c);        //在指定位置插入n个字符C
string& erase(int pos,int n=npos);          ///删除从pos开始的n个字符

string子串

功能描述：从字符串中得到想要的子串

#include<string>
...
string substr(int pos=0,int n=npos) const;    //返回由pos开始的n个字符组成的字符串

2.vector容器

功能：和数组非常相似，也称单端数组

与普通数组的区别：数组是静态空间，vector可以动态扩展

动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

vector的迭代器是支持随机访问的迭代器

vector构造函数

功能描述：创建vector容器

#include<vector>
...
vector<T> v;                    //采用模板实现类实现，默认构造函数
vector(v.begin(),v.end());      //将v[begin(),end()]区间中的元素拷贝给本身
vector(n,elem);                 //构造函数将n个elem拷贝给本身
vector(const vector& vec);      //拷贝构造函数

vector赋值操作

功能描述：给vector容器赋值

#include<vector>
...
vector& operator(const vector &vec);      //重载等号操作符
assign(beg,end);                           //将[beg end)区间中的数据拷贝赋值给本身
assign(n,elem);                           //将n个elem拷贝赋值给本身

vector容量和大小

功能描述：对vector容器的容量和大小操作

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

vector插入和删除

功能描述：对vector容器进行插入、删除操作

#include<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();                                           //删除容器中所有元素

vector数据存取

功能描述：对vector中的数据的存取操作

#include<vector>
...
at(int idx);    //返回索引idx所指的数据
operator[];     //返回索引idx所致的数据
front();        //返回容器中第一个数据元素
back();         //返回容器中最后一个数据元素

vector互换容器

功能描述：实现两个容器内元素进行互换

#include<vector>
..
swap(vec);    //将vec与本身的元素互换

实际用途(巧用swap)可以收缩内存空间

vector预留空间

功能描述：较少vector在动态扩展容量时的扩展次数

#include<vector>
...
reserve(int len);    //容器预留len个元素长度，预留位置不初始化，元素不可访问

3.deque容器

功能：双端数组，可以对头端进行插入删除操作

deque与vector区别：

vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关

deque构造函数

功能描述：deque容器构造

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

deque赋值操作

功能描述：给deque容器进行赋值

#include<deque>
...
deque& operator=(const deque &deg);    //重载等号操作符
assign(beg,end);                       //将[beg,end]区间中的数据拷贝赋值给本身
assign(n,elem);                        //将n个elem拷贝赋值给本身

deque大小操作

功能描述：对deque容器的大小进行操作

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

deque的插入和删除

功能描述：向deque容器中插入和删除数据

#include<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位置的数据，返回下一个数据的位置。

deque数据存取操作

功能描述：对deque 中的数据的存取操作

#include<deque>
...
at(int idx);    //返回索引idx所指的数据
operator[];     //返回索引idx所指的数据
front();        //返回容器中第一个数据元素
back(); I       //返回容器中最后一个数据元素

deque排序

功能描述：利用算法实现对deque容器进行排序

#include<deque>
...
sort(iterator beg,iterator end)     //对beg和end区间内元素进行排序

4.stack容器

概念：一种先进后出的数据结构

注:栈不允许有遍历行为

stack的常用接口

#include<stack>
...
//构造函数
stack<T>stk;                            //stack采用模板类实现。stack对象的默认构造形式
stack(const stack &stk);                 //拷贝构造函数
//赋值操作
stack& operator=(const stack &stk);      //重载等号操作符
//数据存取
push(elem);                              //向栈顶添加元素
pop();                                   //向栈顶移除第一个元素
top();                                   //返回栈顶元素
//大小操作：
empty();                                 //判断堆栈是否为空
size();                                  //返回栈的大小

5.queue容器

概念：一种先进先出的数据结构

queue的常用接口

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

6.list容器

功能：将数据进行链式存储

链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列结点组成

结点的组成:一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

list构造函数

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

list赋值和交换

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

list大小操作

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

resize(num, elem);      //重新指定容器的长度为num，若容器变长，则以elem值填充新位置
                        //如果容器变短，则末尾超出容器长度的元素被制除

list插入和删除

#include<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值匹配的元素

list数据存取

#include<list>
...
front();    //返回第一个元素
back();     //返回最后一个元素

注：list容器里有重载++运算符，list<int>::iterator it=l1.begin(); it++;正确 it=it+1;错误

list的反转和排序

#include<list>
...
reverse();    //链表反转
sort()        //链表排序(默认升序)
sort(myCmp);  //排序(降序)
bool myCmp(int v1,int v2){ return v1>v2; }

7.set / multiset容器

特点：所有元素插入后会自动排序(默认从小到大，若要改变规则，对组那里会提)

本质：set / multiset 属于关联式容器，底层结构是用二叉树实现

set 和 multiset区别：

set不允许容器有重复的元素

multiset允许容器有重复的元素

因为在插入数据时，set插入同时会返回结果，表示是否插入成功，multiset不会监测数据，因此可以插入重复数据

set构造和赋值和插入

#include<set>
...
set<T>s;                //默认构造函数
set(const set& st);     //拷贝构造函数
insert(elem);           //插入元素elem

注：set容器插入数据只能用insert();

set大小和互换

#include<set>
..
size();        //返回容器中元素的数目
empty();       //判断容器是否为空
swap(st);        //交换两个集合容器

set插入和删除

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

set查找和统计

#include<set>
..
find(key);     //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);    //统计key的元素个数

8.对组

功能描述：成对出现的数据，利用对组可以返回两个数据

创建方式

...
pair<type,type>p(value1,value2);
pair<type,type>p=make_pair(value1,value2);

set容器内置类型指定排序

学习目标：set容器默认排序从小到大，掌握如何改变排序规则

利用仿函数，可以改变排序规则

#include<set>
..
class MyCmp
{
    public:
        bool operator()(int v1,int v2) { return v1>v2; }    //仿函数
}
set<int,MyCmp>S;

set容器自定义类型指定排序

与内置类似

8.map容器

简介：map中所有元素都是pair

pair中第一个元素为key(键值)，起到索引作用，第二个元素为value(实值)

所有元素都会根据元素的键值自动排序

本质：map/multimap属于关联式容器，底层结构使用二叉树实现

优点：可以根据key值快速好到value值

map和multimap的区别：

map不允许有重复的key值元素

multimap允许容器中有重复key值与元素

map的构造和赋值

#include<map>
...
//构造
map<T1,T2>mp;                     //map默认构造函数
map(const map& mp);               //拷贝构造函数
//赋值
map& operator=(const map& mp);    //重载等号运算符

map大小和交换

#include<map>
...
size();     //返回容器中元素的数目
empty();    //判断容器是否为空
swap(st);   //交换两个集合容器

map插入和删除

#include<map>
...
insert(elem);      //在容器中插入元素。
clear();           //清除所有元素
erase(pos);        //删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg, end);   //删除区间[beg,end]的所有元素，返回下一个元素的迭代器
erase(key);        //删除容器中值为key的元素
-----------
插入的两种方式
insert(pair<type,type>(elem,elem);
insert(make_pair(elem,elem));

map查找和统计

#include<map>
...
find(key);     //查找key是否存在，若存在，返回改建的元素的迭代器，
                                 若不存在，返回set.end()
count(key);    //统计key的元素个数

map容器排序

map容器默认排序规则为按照key值进行从大到小排序

若要改变排序规则，则利用仿函数，与set类似

函数对象

1.函数对象：

概念：

重载函数调用操作符的类，其对象常称为函数对象

函数对象是哦那个重载的()时，行为类似函数调用，也叫仿函数

本质：

函数对象(仿函数)时一个类，不是一个函数

特点：

函数对象在使用时，可以像普通函数那样调用,可以有参数，可以有返回值

函数对象超出普通团数的概念，函数对象可以有自己的状态

函数对象可以作为参数传递

示例：

#include<iostream>
using namespace std;
//函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
class MyAdd
{
public:
	int operator()(int v1,int v2)
	{
		return v1+v2;	
	}
};
void test01()
{
    MyAdd myAdd;
    cout<<myAdd(10,10)<<endl;
}
//函数对象曹处普通函数的概念，函数对象可以有自己的状态
class MyPrint
{
public:
	MyPrint()
	{
		this->count=0;
	}
	void operator()(string test)
	{
		cout<<test<<endl;
		count++;
	}
	int count;	//内部状态 
};
void test02()
{
	MyPrint myPrint;
	myPrint("hello world");
	myPrint("hello world");
	cout<<"调用了"<<myPrint.count<<"次"<<endl;
}
//函数对象可以作为参数传递
void DoPrint(MyPrint& mp,string test)
{
	mp(test);
}
void test03()
{
	MyPrint myPrint;
	DoPrint(myPrint,"Hello c++");
} 
int main()
{
	test01();
    test02();
    test03();
	return 0;
}

2.谓词

概念：返回bool类型的仿函数称为谓词

如果operator()接受一个参数，那么叫做一元谓词

如果operator()接受两个参数，那么叫做二元谓词

一元谓词

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class CreaterFive
{
public:
	bool operator()(int val)
	{
		return val>5;
	}	
};
void test()
{
	vector<int>v;
	for(int i=0;i<10;i++)
		v.push_back(i);
	vector<int>::iterator it=find_if(v.begin(),v.end(),CreaterFive());
	if(it==v.end())
		cout<<"未找到"<<endl;
	else
		cout<<*it<<endl;
}
int main()
{
	test();
	return 0;
}

二元谓词

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class MyCmp
{
public:
	bool operator()(int v1,int v2)
	{
		return v1>v2;
	}	
};
void test()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(600);
	sort(v.begin(),v.end());
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
		cout<<*it<<" ";
	cout<<endl<<"改变排序规则后"<<endl;
	sort(v.begin(),v.end(),MyCmp());
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
		cout<<*it<<" ";
}
int main()
{
	test();
	return 0;
}

3.内建函数

STL内建了一些函数对象。分为：算数类函数对象,关系运算类函数对象，逻辑运算类仿函数。这些仿函数所产生的对象，用法和一般函数完全相同。

使用内建函数对象，需要引入头文件

#include<functional>

算术仿函数

功能描述：实现四则运算

其中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>      //取反仿函数

示例

#include<iostream>
#include<functional>
using namespace std;
int main()
{
	plus<int>p;
	cout<<p(5,10)<<endl;
	negate<int>n;
	cout<<n(1)<<endl;
	return 0; 
}

关系仿函数

功能描述：实现关系对比

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>      //小于等于

示例

#include<iostream>
#include<vector>
#include<functional>
#include<algorithm>
using namespace std;
class cmp
{
public:
	bool operator()(int v1,int v2)
	{
		return v1>v2;
	}
};
int main()
{
	vector<int>v;
	v.push_back(1);
	v.push_back(5);
	v.push_back(4);
	v.push_back(6);
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
		cout<<*it<<" ";
	cout<<endl;
//	sort(v.begin(),v.end(),cmp());
    //greater<int>() //内建函数对象
	sort(v.begin(),v.end(),greater<int>());
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
		cout<<*it<<" ";
}

逻辑仿函数

功能描述：实现逻辑运算

template<class T> bool logical_and<T>//逻辑与
template<class T> bool logical_or<T>//逻辑或
template<class T> bool logical_not<T>//逻辑非

示例

#include<iostream>
#include<functional>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
	vector<bool>v;
	v.push_back(true); 
	v.push_back(false); 
	v.push_back(true); 
	v.push_back(true);
	for(vector<bool>::iterator it=v.begin();it!=v.end();it++)
		cout<<*it<<" ";	
	cout<<endl;
	vector<bool>v2;
    //给v2分配空间
	v2.resize(v.size());
	transform(v.begin(),v.end(),v2.begin(),logical_not<bool>());
	cout<<"取反后"<<endl;
	for(vector<bool>::iterator it=v2.begin();it!=v2.end();it++)
		cout<<*it<<" ";	
}

常用算法

概述

算法主要由头文件<algorithm>、<functional>、<numeric>组成

<algorithm>是所有STL头文件中最大的一个,其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等…
<numeric>体积很小，只包括在几个序列容器上进行的简单运算的模板函数.
<functional> 定义了一些模板类,用以声明函数对象。

1.常见遍历算法

1.for_each

//beg 开始迭代器
//end 结束迭代器
//_callback  函数回调或者函数对象
//return 函数对象
for_each(iterator beg,iterator end,_callback);

功能：遍历容器

示例

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//匿名函数
class MyPrint
{
public:
	void operator()(int val)
	{
		cout<<val<<" ";
	}
};
//普通函数
void Print(int val)
{
	cout<<val<<" ";
}
int main()
{
	vector<int>v;
	for(int i=0;i<10;i++)
		v.push_back(i);
	for_each(v.begin(),v.end(),MyPrint());    //普通函数
    for_each(v.begin(),v.end(),Print);        //匿名函数方式
	return 0;	
}

2.transform

//beg1 源容器开始迭代器
//end1 源容器结束迭代器
//beg2 目标容器开始迭代器
//_cakkback 回调函数或者函数对象
//return 返回目标容器迭代器
transform(iterator beg1,iterator end1,iterator beg2,_callbakc)

功能：搬运容器到另一个容器

示例

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class Tran
{
public:
	int operator()(int v)
	{
		return v;
	}
};
class MyPrint
{
public:
	void operator()(int v)
	{
		cout<<v<<" ";
	}	
};
void Print(int val)
{
	cout<<val<<" ";
}
int main()
{
	vector<int>v;
	for(int i=0;i<10;i++)
		v.push_back(i);
	vector<int>v2;
    //注意这里，必须给v2分配大小
	v2.resize(v.size());
	transform(v.begin(),v.end(),v2.begin(),Tran());
	for_each(v2.begin(),--v2.end(),MyPrint());
	return 0;	
}

2.常用查找算法

1.find

// 按值查找元素
// beg 开始选代器
// end 结束选代器
// value 查找的元素
// 找到返回指定位置迭代器，找不到返回结束迭代器位置
find(iterator beg,iterator end,value);

2.find_if

// 按值查找元素
// beg 开始选代器
// end 结束迭代器
// _Pred 函数或者谓词 (返回bool类型的仿函数)
// 找到返回指定位去代器，找不到返回结束迭代器位置
find_if(iterator beg, terator end,_Pred);

3.adjacent find

//查找相邻重复元素
// beg 开始选代器
// end 结束选代器
// return 返回相邻元素的第一个位置的迭代器
adjacent find(iterator beg,iterator end);

4.binary_search

// 查找指定的元素
// 注意: 在无序序列中不可用
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素
// 找到return true，没找到 return false
bool bihary search(iterator beg,iterator end,value);

注：无序序列不可用

5.count

// 统计元素出现次数
// beg 开始选代器
// end 结束选代器
// value 统计的元素
// return一个int表示次数
count(iterator beg,iterator end,value);

6.count_if

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

示例：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class  Greater20
{
public:
	bool operator()(int v)
	{
		return v>20;
	}	
};
int main()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(40);
	v.push_back(80);
	int num=count_if(v.begin(),v.end(),Greater20());
	cout<<"大于20的元素个数为："<<num<<endl;
	return 0;	
}

3.常见的排序算法

1.sort

// sort算法 容器元素排序
// beg 开始迭代器
// end 结束迭代器
// _callback 回调函数或者谓词
// 找到返回指定位置迭代器，找不到返回结束迭代器位置
sort(iterator beg, iterator end, _callback)

2.merge

// merge算法 容器元素合并，并存储到另一容器中
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)

3.random_shuffle

//随机打乱顺序
random_shuffle(iterator beg,iterator end)

4.reverse

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

4.常用拷贝和替换算法

1.copy

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

2.replace

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

3.replace_if

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

4.swap

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

5.常用算数生成算法

1.accumulate

// accumulate 算法 ，计算容器元素累计总和
// beg 容器开始迭代器
// end 容器结束迭代器
// value 起始的累加值
#include<numeric>
accumulate(iterator beg,iterator end,value)

2.fill

fill 算法，向容器中添加元素
// beg 容器开始迭代器
// end 容器结束迭代器
// value 填充元素
#include<numeric>
fill(iterator beg,iterator end,value)

6.常用集合算法

1.set_intersection

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

2.set_union

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

3.set_difference

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