（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]加入堆,重新調整堆