STL基本使用方法总结及一些补充

（Hint：如果在main函数中定义STL的话会比较费时间，对于某些题目来说会超时，所以一般将STL定义为全局变量，这样的话快很多~）

一、vector向量容器

头文件#include <vector>

1.创建vector对象
（1）不指定容器大小
vector<int> V;
（2）指定容器大小
vector<int> V(10);
（3）指定容器大小和初始值

vector<int> V(10,0);

2.尾部元素扩张

V.push_back(2);

3.插入元素
（1）在最前面插入元素
V.insert(V.begin(),2);
（2）在第二个元素前插入元素
V.insert(V.begin()+2,2);
（3）在末尾插入元素

V.insert(V.end(),2);//相当于V.push_back(2)

4.删除元素
（1）删除第二个元素
V.erase(V.begin()+2);
（2）删除[1,5]区间所有元素
V.erase(V.begin()+1,V.begin()+5);
（3）清空向量

V.clear();

5.向量的大小
（1）向量大小
V.size();
（2）向量是否为空

V.empty();

6.用迭代器访问vector元素

vector<int>::iterator it;

for(it=V.begin();it!=V.end();it++)

cout<<*it<<" ";

7.使用reverse反向排列算法

reverse(V.begin(),V.end());

8.使用sort排序算法
（1）升序排列
sort(V.begin(),V.end());
（2）降序排列
bool Comp(const int &A,const int &B)
{
return A>B;
}

sort(V.begin(),V.end(),Comp);

二、stack堆栈容器

#include <stack>

1.创建stack对象

stack<int> S;

2.元素入栈

S.push(2);

3.读取栈顶元素

S.top();

4.元素出栈

S.pop();

5.堆栈大小

S.size();

6.堆栈是否为空

S.empty();

三、queue队列容器

#include <queue>

1.创建queue对象

queue<int> Q;

2.读取队首元素

Q.front();

3.读取队尾元素

Q.back();

4.队列大小

Q.size();

5队列是否为空

Q.empty();

6.元素入队

Q.push(2);

7.元素出队
Q.pop();

做一些补充：队列是没有iterator的，不允许这样遍历，而且队列是逻辑上地址相邻，如果想遍历的话，可以每次输出队首元素，然后pop（）方法，当然还有其他的实现方法，欢迎补充。

四、priority_queue优先队列容器

#include <priority_queue>

1.定义优先队列

从大到小输出：priority_queue<int> Q;//默认方式，大优先,最大堆
从小到大输出：priority_queue<int, vector<int>, greater<int> >  Q;//最小堆，小优先

2.元素入队

Q.push(2);

3.元素出队

Q.pop();

4.队列大小

Q.size();

5.读取队首元素

Q.top();

6.队列是否为空

Q.empty();

7.重载"<"操作符定义优先级
struct Info
{
float Score;
string Name;
bool operator < (const Info &I) const
{
//按照Score由小到大排列
return I.Score<Score;
}
};

priority_queue<Info> Q;

8.重载"()"操作符定义优先级
struct Comp
{
bool operator () (const int &A,const int &B)
{
//由小到大排列
return A>B;
}
};

priority_queue<int,vector<int>,Comp> Q;

五、deque双端队列容器

#include <dueue>

1.创建deque对象

（1）不指定容器大小
deque<int> D;
（2）指定容器大小
deque<int> D(10);
（3）指定容器大小和初始值

deque<int> D(10,0);

2.插入元素
（1）从尾部插入元素，会不断扩张队列
D.push_back(2);
（2）从头部插入元素，将原有元素覆盖
D.push_front(2);
（3）从中间插入元素，将原有元素覆盖

D.insert(D.begin()+1,2);

3.删除元素
（1）从头部删除元素
D.pop_front();
（2）从尾部删除元素
D.pop_back();
（3）从中间删除元素
D.erase(D.begin()+1);
（4）清空deque 对象

D.clear();

4.前向遍历

deque<int>::iterator it;

for(it=D.begin();it!=D.end();it++)

cout<<*it<<" ";

5.反向遍历

deque<int>::reverse_iterator rit;

for(rit=D.rbegin();rit!=D.rend();rit++)

cout<<*rit<<" ";

六、list双向链表容器

#include <list>

1.创建list对象

（1）不指定容器大小
list<int> L;
（2）指定容器大小

list<int> L(10);

2.插入元素
（1）尾部插入元素，链表自动扩张
L.push_back(2);
（2）首部插入元素，链表自动扩张
L.push_front(2);

（3）中间插入元素（在迭代器位置处），链表自动扩张

list<int>::iterator it;
lt=L.begin();
it++; //迭代器只能进行++或--操作，不能进行+n操作
L.insert(it,2);

3.删除元素
（1）删除链表中一个元素，值相同的元素都会被删除
L.remove(2);
（2）删除链表首元素
L.pop_front();
（3）删除链表尾元素
L.pop_back();
（4）删除迭代器位置上的元素
list<int>::iterator it;
it++;
it++;

L.erase(it):

（5）清空链表

L.clear();

4.元素排序
//升序排列

L.sort();

5.剔除连续重复元素

L.unique();

6.查找元素

list<int>::iterator it;

//成功返回元素迭代器位置，失败返回end()迭代器位置

it=find(L.begin(),L.end(),2);

七、bitset位集合容器

#include <bitset>

1.创建bitset对象

bitset<10> B;

2.设置元素值
（1）一次性将元素设置为1
B.set();
（2）将某位设置为1
B.set(2,1)
（3）将某位设置为0

B.reset(2);

八、set集合容器：集合是一个存放同类型数据的容器，集合里的值有唯一性，而且加入集合的元素会被自动排序，内部采用的是非常高效的平衡检索二叉树（红黑树），常使用的是其唯一性和自动排序属性。

#include <set>

1.创建set集合对象

set<int> S;

2.插入元素

S.insert(2);

3.删除元素

S.erase(2);

4.查找元素
set<int>::iterator it;
//成功返回元素迭代器位置，失败返回end()迭代器位置

it=S.find(2);

5.自定义比较函数
（1）元素不是结构体
struct Comp
{
bool operator () (const int &A,const int &B)
{
//由大到小的顺序
return A>B;
}
};
set<int,Comp> S;
（2）元素是结构体
struct Info
{
float Score;
string Name;
bool operator < (const Info &I) const
{
//按Score由大到小排列
return I.Score<Score;
}
};

set<Info> S;

九、multiset多重集合容器

#include <multiset>

1.创建multiset对象

multiset<int> S;

2.插入元素

S.insert(2);

3.删除元素
int N;
//删除为的所有元素，返回删除元素总数

N=S.erase(2);

4.查找元素
multiset<int>::iterator it;
//成功返回第一个重复元素迭代器位置，失败返回end()迭代器位置
it=S.find(2);

十、map映照容器：标准库map类型是一种以键-值(key-value)存储的数据类型。

#include <map>

1.创建map对象

map<int,char> M;

map<k, v> m;

map<k, v> m(m2);  //创建了m2的副本m

map<k, v> m(b, e);  //创建了map对象m，并且存储迭代器b和e范围内的所有元素的副本

map中元素的插入

m[ i ] = 'c';

m.insert(make_pair(i, i));

m.insert(iter, e);

2.删除元素

M.erase(2);

3.查找元素
map<int,char>::iterator it;
//成功返回键值所在迭代器位置，失败返回end()迭代器位置

it=M.find(2);

4.自定义比较函数
（1）元素不是结构体
struct Comp
{
bool operator () (const int &A,const int &B)
{
//键值由大到小
return A>B;
}
};

map<int,char,Comp> M;

（2）元素是结构体
struct Info
{
float Score;
string Name;
bool operator < (const Info &I) const
{
//按Score由大到小排列
return I.Score<Score;
}
};

map<Info,int> M;

十一、multimap多重映照容器

#include <multimap>

1.创建multimap对象

multimap<int,char> M;

2.插入元素

M.insert(pair<int,char>(2,'2'));

3.删除元素（键值相同元素全部删除）

M.erase(2);

4.查找元素
multimap<int,char>::iterator it;
//成功返回第一个重复键值迭代器位置，失败返回end()迭代器位置

it=M.find(2);

十二、string基本字符系列容器

#include <string>

1.创建string对象

string Str;

2.尾部添加字符

Str+="good";

3.插入字符
string::iterator it;
it=Str.begin();

Str.insert(it+1,'2');

4.删除字符
（1）删除第二个元素
Str.erase(Str.begin()+2);
（2）删除[1,5]区间所有元素

Str.erase(Str.begin()+1,Str.begin()+5);

5.替换字符

Str.replace(2,4,"good");

6.搜索字串
//成功返回第一个字符下标，失败返回4294967295

Str.find("good");

7.字符串比较
//相等返回，Str大返回，Str小返回-1

Str.compare("good");

8.string对象与数值相互转换
string ConvertToString(double X)
{
ostringstream O;
if(O<<X)
return O.str();
return "Conversion Error";

}

double ConvertFromString(const string &Str)
{
double X;
istringstream I(Str);
if(I>>X)
return X;
return 0.0;

}

十三、heap算法

#include <heap>

1.堆的基本操作
struct Point
{
int F;
int Index;
bool operator < (const Point &P) const
{
if(F!=P.F)
return P.F>F; //按照F从大到小排列
else
return P.Index<Index; //按照Index从小到大排列
}
};

Point P[30];

make_heap(P,P+i); //构造堆,堆顶在P[i-1]

pop_heap(P,P+i); //P[i-1]出堆,调整其他元素

PF=P[i-1].F;

PI=P[i-1].Index;

push_heap(P,P+i); //将P[i-1]加入堆,重新调整堆