STL常见函数总结

STL

常见函数总结

 

 

#include<bitset>                     

#include<deque> 

#include<list> 

#include<map> 

#include<set> 

#include<stack> 

#include<vector> 

#include<algorithm> 

#include<string> 

#include<queue> 

容器和算法

 

顺序容器

 

1 vector//

支持快速随机访问

 

vector<int> f,f1; 

vector<int>::iterator iter,q,h; 

int n,x; 

   f.push_back(x);

在尾部插入元素

x,

返回

void; 

   f.insert(iter,x);

在

iter

前面插入

x

，返回指向新添加元素的迭代器

; 

   f.insert(iter,n,x);

在

iter

前面插入

n

个

x

，返回

void; 

   f.insert(iter,q,h);

在迭代器

iter

前面插入

q

和

h

范围内的所以元素；

 

   f.size(); 

返回类型：

vector<int>::size_type,

也可直接用

int

，

long 

   f.empty();

返回布尔值

 

   f.back();

最后一个元素

 

   f.front();

返回第一个元素

 

   f[n] 

返回第

n

个元素

 

   f.erase(iter)

删除

iter

指向的元素，返回所删除值后面的元素的迭代器，

若删除的是最后一个元素返回

f.end()

一样的位置

 

   f.erase(q,h)

删除

q-h

所有元素（包括

q

，不包括

h)

，返回指向后面的的若

h

就是

f.end(),

还返回

f.end(); 

   f.clear();

清空所以元素

,

返回

void 

   f.pop_back()

删除最后一个元素，返回

void 

   

可以直接赋值

f1=f;

可以直接比较大小

 

   f1=swap(f); 

   f.assign(q,h);f

先清空，

然后把来自另一个

vector

的从

q

到

h

的元素复制

进来

 

   f.assign(n,x);f

先清空，然后赋为

n

个

x 

   

2 list//

支持快速插入删除

,

就是个链表

 

   f.push_front(x);

不能用

f[n]

来访问

 

   f.pop_front();

返回

STL

常见函数总结

 

 

#include<bitset>                     

#include<deque> 

#include<list> 

#include<map> 

#include<set> 

#include<stack> 

#include<vector> 

#include<algorithm> 

#include<string> 

#include<queue> 

容器和算法

 

顺序容器

 

1 vector//

支持快速随机访问

 

vector<int> f,f1; 

vector<int>::iterator iter,q,h; 

int n,x; 

   f.push_back(x);

在尾部插入元素

x,

返回

void; 

   f.insert(iter,x);

在

iter

前面插入

x

，返回指向新添加元素的迭代器

; 

   f.insert(iter,n,x);

在

iter

前面插入

n

个

x

，返回

void; 

   f.insert(iter,q,h);

在迭代器

iter

前面插入

q

和

h

范围内的所以元素；

 

   f.size(); 

返回类型：

vector<int>::size_type,

也可直接用

int

，

long 

   f.empty();

返回布尔值

 

   f.back();

最后一个元素

 

   f.front();

返回第一个元素

 

   f[n] 

返回第

n

个元素

 

   f.erase(iter)

删除

iter

指向的元素，返回所删除值后面的元素的迭代器，

若删除的是最后一个元素返回

f.end()

一样的位置

 

   f.erase(q,h)

删除

q-h

所有元素（包括

q

，不包括

h)

，返回指向后面的的若

h

就是

f.end(),

还返回

f.end(); 

   f.clear();

清空所以元素

,

返回

void 

   f.pop_back()

删除最后一个元素，返回

void 

   

可以直接赋值

f1=f;

可以直接比较大小

 

   f1=swap(f); 

   f.assign(q,h);f

先清空，

然后把来自另一个

vector

的从

q

到

h

的元素复制

进来

 

   f.assign(n,x);f

先清空，然后赋为

n

个

x 

   

2 list//

支持快速插入删除

,

就是个链表

 

   f.push_front(x);

不能用

f[n]

来访问

 

   f.pop_front();

返回

STL

常见函数总结

 

 

#include<bitset>                     

#include<deque> 

#include<list> 

#include<map> 

#include<set> 

#include<stack> 

#include<vector> 

#include<algorithm> 

#include<string> 

#include<queue> 

容器和算法

 

顺序容器

 

1 vector//

支持快速随机访问

 

vector<int> f,f1; 

vector<int>::iterator iter,q,h; 

int n,x; 

   f.push_back(x);

在尾部插入元素

x,

返回

void; 

   f.insert(iter,x);

在

iter

前面插入

x

，返回指向新添加元素的迭代器

; 

   f.insert(iter,n,x);

在

iter

前面插入

n

个

x

，返回

void; 

   f.insert(iter,q,h);

在迭代器

iter

前面插入

q

和

h

范围内的所以元素；

 

   f.size(); 

返回类型：

vector<int>::size_type,

也可直接用

int

，

long 

   f.empty();

返回布尔值

 

   f.back();

最后一个元素

 

   f.front();

返回第一个元素

 

   f[n] 

返回第

n

个元素

 

   f.erase(iter)

删除

iter

指向的元素，返回所删除值后面的元素的迭代器，

若删除的是最后一个元素返回

f.end()

一样的位置

 

   f.erase(q,h)

删除

q-h

所有元素（包括

q

，不包括

h)

，返回指向后面的的若

h

就是

f.end(),

还返回

f.end(); 

   f.clear();

清空所以元素

,

返回

void 

   f.pop_back()

删除最后一个元素，返回

void 

   

可以直接赋值

f1=f;

可以直接比较大小

 

   f1=swap(f); 

   f.assign(q,h);f

先清空，

然后把来自另一个

vector

的从

q

到

h

的元素复制

进来

 

   f.assign(n,x);f

先清空，然后赋为

n

个

x 

   

2 list//

支持快速插入删除

,

就是个链表

 

   f.push_front(x);

不能用

f[n]

来访问

 

   f.pop_front();

返回

void

STL

常见函数总结

 

 

#include<bitset>                     

#include<deque> 

#include<list> 

#include<map> 

#include<set> 

#include<stack> 

#include<vector> 

#include<algorithm> 

#include<string> 

#include<queue> 

容器和算法

 

顺序容器

 

1 vector//

支持快速随机访问

 

vector<int> f,f1; 

vector<int>::iterator iter,q,h; 

int n,x; 

   f.push_back(x);

在尾部插入元素

x,

返回

void; 

   f.insert(iter,x);

在

iter

前面插入

x

，返回指向新添加元素的迭代器

; 

   f.insert(iter,n,x);

在

iter

前面插入

n

个

x

，返回

void; 

   f.insert(iter,q,h);

在迭代器

iter

前面插入

q

和

h

范围内的所以元素；

 

   f.size(); 

返回类型：

vector<int>::size_type,

也可直接用

int

，

long 

   f.empty();

返回布尔值

 

   f.back();

最后一个元素

 

   f.front();

返回第一个元素

 

   f[n] 

返回第

n

个元素

 

   f.erase(iter)

删除

iter

指向的元素，返回所删除值后面的元素的迭代器，

若删除的是最后一个元素返回

f.end()

一样的位置

 

   f.erase(q,h)

删除

q-h

所有元素（包括

q

，不包括

h)

，返回指向后面的的若

h

就是

f.end(),

还返回

f.end(); 

   f.clear();

清空所以元素

,

返回

void 

   f.pop_back()

删除最后一个元素，返回

void 

   

可以直接赋值

f1=f;

可以直接比较大小

 

   f1=swap(f); 

   f.assign(q,h);f

先清空，

然后把来自另一个

vector

的从

q

到

h

的元素复制

进来

 

   f.assign(n,x);f

先清空，然后赋为

n

个

x 

   

2 list//

支持快速插入删除

,

就是个链表

 

   f.push_front(x);

不能用

f[n]

来访问

 

   f.pop_front();

返回

void

STL

常见函数总结

 

 

#include<bitset>                     

#include<deque> 

#include<list> 

#include<map> 

#include<set> 

#include<stack> 

#include<vector> 

#include<algorithm> 

#include<string> 

#include<queue> 

容器和算法

 

顺序容器

 

1 vector//

支持快速随机访问

 

vector<int> f,f1; 

vector<int>::iterator iter,q,h; 

int n,x; 

   f.push_back(x);

在尾部插入元素

x,

返回

void; 

   f.insert(iter,x);

在

iter

前面插入

x

，返回指向新添加元素的迭代器

; 

   f.insert(iter,n,x);

在

iter

前面插入

n

个

x

，返回

void; 

   f.insert(iter,q,h);

在迭代器

iter

前面插入

q

和

h

范围内的所以元素；

 

   f.size(); 

返回类型：

vector<int>::size_type,

也可直接用

int

，

long 

   f.empty();

返回布尔值

 

   f.back();

最后一个元素

 

   f.front();

返回第一个元素

 

   f[n] 

返回第

n

个元素

 

   f.erase(iter)

删除

iter

指向的元素，返回所删除值后面的元素的迭代器，

若删除的是最后一个元素返回

f.end()

一样的位置

 

   f.erase(q,h)

删除

q-h

所有元素（包括

q

，不包括

h)

，返回指向后面的的若

h

就是

f.end(),

还返回

f.end(); 

   f.clear();

清空所以元素

,

返回

void 

   f.pop_back()

删除最后一个元素，返回

void 

   

可以直接赋值

f1=f;

可以直接比较大小

 

   f1=swap(f); 

   f.assign(q,h);f

先清空，

然后把来自另一个

vector

的从

q

到

h

的元素复制

进来

 

   f.assign(n,x);f

先清空，然后赋为

n

个

x 

   

2 list//

支持快速插入删除

,

就是个链表

 

   f.push_front(x);

不能用

f[n]

来访问

 

   f.pop_front();

返回

void 

名人堂：众名人带你感受他们的驱动人生

马云 任志强 李嘉诚 柳传志 史玉柱

3 

deque//

双端队列，两头都有

vector

的高效性质，还，可以实现元素的随机访

问

 

   f.push_front(x); 

   f[n]; 

   f.pop_front();

返回

void 

4 stack//

后进先出栈

 

   s.empty() 

   s.size() 

   s.pop()    

删除栈顶元素，不返回值

 

   s.top()    

返回栈顶元素的值，但不删除栈顶元素

 

   s.push(x) 

压栈

 

5 queue//

先进先出队列

 

   s.empty() 

   s.size() 

   s.pop()

删除队首元素，不返回值

 

   s.front()

返回队首值，但不删除

 

   s.back()

返回队尾值，但不删除

 

   s.push(),

在最后插入元素

 

6 priority_queue //

有优先级管理的队列

 

   s.empty() 

   s.size() 

   s.pop()

删除队首元素，不返回值

 

   s.front()

返回队首值，但不删除

 

   s.top(

）返回具有最高优先级的元素，但不删除

 

   s.push(),

在适当位置插入新元素

 

   

定义方法

 

   priority_queue<int,vector<int>,greater<int>> 

   priority_queue<int,vector<int>,less<int>> 

   priority_queue<int> 

7 string 

和

vector

差不多其实，特殊的

vector? 

int pos; 

char ch[100]; 

   getline(cin,s); 

   s.insert(iter,t); iter

前插

t 

   s.insert(iter,n,t); iter

前

n

个插

t 

   s.insert(iter,q,h); 

   s.earse(iter); 

   s.earse(q,h); 

   s.insert(pos,n,t);

在

pos

前插入

n

个

t 

   s.insert(pos,s1); 

在

pos

前插入

s1 

   s.earse(pos,n);

删除

pos

开始的

n

个字符

 

   s.insert(pos,ch,n); 

   s.insert(pos,ch); 

   s.substr(pos,n)

；返回从

pos

开始的

n

个字符的字符串

 

   s.substr(pos); 

   s.replace(pos.len.s1);

删除

pos

开始的

len

个字符并以

s1

代替插进去

 

   s.replace(q,h,s1); 

   s.find(s1) s1

在

s

中第一次出现的位置

 

   s.rfind(s1) s1

在

s

中最后一次出现的位置

 

   s.find_first_of(s1) 

在

s

中查找

s

任意字符第一次出现

 

   s.find_last_of(s1) 

在

s

中查找

s

任意字符最后一次出现

 

   s.find_first_not_of(s1) 

   s.find_last_not_of(s1) 

   

每个

s1

都有四种重载版本

 s1,pos

（从

pos

开始找），

s1,pos,n(

匹配

s1

的

前

n

个字母）

 

   string

的比较：

 

    s==s1,s>s1,s<s1

最一般的

 

    s.compare(s1) 

    s.compare(pos,n,s1);s

从

pos

开始的

n

个字符，

 

    

同理，这里的

s1

也有多种重载版本

 

 

关联容器

 

1 map(

键值对应），键要可排序类型

 

map<string,int> f; 

map<string,int>::key_type 

键的类型

 

map<string,int>::mapped_type 

值的类型

 

map<string,int>::value_type pair

类型

,

其中

first

为一个常量，而

sencond

为一个可变量

 

map

中添加元素：

 

   

直接下标添加：

f["hello"]=2;

（建立了键后首先赋值为

0

）

(

若原来有这个

“hello”，则是修改了这个键对应的值）

 

   

用

insert

添加新元素：

f.insert(map<string,int>::value_type("hello",1)); 

        f.insert(make_pair("hello",1)); 

        insert(pair),

返回一个

pair

类型

（

 pair<map<string,int>::iteratro, 

bool> 

ret

）对象，包括一个指向插入键

的迭代器，和

bool

类型的判断是否插入的布尔值，如果键已经存在，就不插入

了

 

map

中查找，读取元素

 

   

下标读取有危险

(

如果没有会插入）

 

   f.count("hello") 

返回”hello"出现的次数，对于

map

，返回的就是

0

或

1 

   f.find("hello") 

返回对应的迭代器，否则返回

f.end()

处

 

删除元素：

 

   f.erase(),1

传入键（返回

0or1)

，

2

传入迭代器

(void)

，

3

传入一对迭代器

(void) 

 

2 set 

set<int> set1,set2; 

添加元素：

set1.insert(x); 

    set2.insert(set1.begin(),set1.end()); 

    set1.find(x); 

    set1.count(x); 

    set1.erase(x); 

1 bitset 

bitset<100> f; 

   f.any() 

是否存在为

1

的二进制位

 

   f.none() 

   f.size() 

   f[n] 

   f.test(n) 

   f.set() 

全部置为

1 

   f.set(n) 

第

n

位置为

1 

   f.reset()

全部置为

0 

   f.reset(n) 

   f.flip()

逐位取反

 

   f.flip(n) 

   f.to_ulong()

把它返回会

unsigned long 

1 algorithm 

unique 

fill 

fill_n 

replace 

replace_copy 

accumulate 

sort 

stable_sort 

count_if 

„„

 

 

1234567890ABCDEFGHIJKLMNabcdefghijklmn!@#$%^&&*()_+.一三五七九贰肆陆扒拾，。青玉案元夕东风夜放花千树更吹落星如雨宝马雕车香满路凤箫声动玉壶光转一夜鱼龙舞蛾儿雪柳黄金缕笑语盈盈暗香去众里寻他千百度暮然回首那人却在灯火阑珊处