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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值