STL是C++语言中一个非常实用的代码库，叫做标准模板库，通常我们使用这个头文件即可导入STL。本文立足与C++，但是python其实也是大同小异。

set

set正如其名，表示的是一个集合，其分为两类，set为数学上的集合，即不含重复元素，multiset为可重集合，即可以包含重复元素我理解这个就是像比于set，insert的时候增加了一维时间戳。两者其内部的实现为一颗红黑树。

set

multiset

定义1

2set 名字;

multiset 名字;

举个例子来说:

1

2

3

4

5set s;

set > ss;

set > ps;

set > vs;

multiset ms;

如果我们需要自己定义类型的话需要自己定义友元函数来重载运算符，与排序是一样的，例如:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27using namespace std;

struct {

int x,y;

friend bool operator < (node A,node B){

if(A.x==B.x){

return A.y

}

return A.x

}

};

int main(void){

node a,b;

a.x=1;a.y=2;

b.x=1;b.y=3;

set A;

A.insert(a);

A.insert(b);

auto x=*A.begin();

cout<

x=*(++A.begin());

cout<

}

output:

1 2

1 3

size函数

表示set中的元素个数，返回一个整形变量，时间复杂度为$O(1)$

使用方式：

1printf("%d",(int)s.size());

clear函数

清空一个集合，无返回值

使用方式:

1s.clear()

count函数

返回set中的值为$x$的元素个数，时间按复杂度为$O(log n+an)$

使用方式：

1printf("%dn",s.count(x));

迭代器

set的迭代器是双向的，支持—,++两种操作。若把 ite++ ，则 ite 将会指向“下一个”元素。这里的下一个是指在 key从小到大排序的结果中，排在ite 下一名的元素。同理，若把ite— ，则 ite会指向排在上一个的元素。“++”，“—”操作的复杂度均为$O (1)$。

使用方式：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18using namespace std;

set s;

set::iterator ite;

int main(void){

s.insert(4);

s.insert(5);

ite=s.begin();

cout<

ite++;

cout<

ite--;

cout<

}

output:

4

5

4

begin函数

表示集合的首迭代器，时间复杂度$O(1)$

使用方式：

1cout<

end函数

由于STL都是左闭右开的，那么end返回的位置其实是类似于string中 的位置，所以我们需要—，才能得到最大的元素的迭代器。其实s.end()存储的是集合中的元素个数

使用方式：

1cout<

遍历

我们通过++运算符以及begin函数和end函数来进行遍历整个集合

1

2

3

4

5

6

7

8

9

10

11using namespace std;

set s;

set::iterator ite;

int main(void){

s.insert(4);

s.insert(5);

for(ite=s.begin();ite!=s.end();ite++){

cout<

}

}

insert函数

向set中插入元素，返回值为插入地址的迭代器以及是否插入成功所组成的pair，时间复杂度为$O(log n)$

使用方式：

1s.insert(5);

erase函数

删除，参数可以是元素或者迭代器，返回下一个元素的迭代器，时间复杂度为 O(log n)，注意在 multiset 中 s.erase(x)会删除所有值为 $x$ 的元素。所以在multiset中一般是和find函数一起使用的。

使用方式:

1

2s.erase(4);

s.erase(s.find(5));

find函数

在集合中找到第一个元素值等于$x$的迭代器，若不存在的话，返回s.end()。时间复杂度为$O(log n)$

1

2

3if(s.find(3)!=s.end()){

cout<

}

lower_bound和upper_bound函数

用法与$find$类似，但查找的条件略有不同，时间复杂度 $O(log n)$。和vector当中的几乎一样。

$s.lowerbound(x)$表示查找 $>=x$的元素中最小的一个，并返回指向该元素的迭代器。

$s.upper bound(x)$表示查找 $>x$ 的元素中最小的一个，并返回指向该元素的迭代器。

例如：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37using namespace std;

set s;

set ::iterator ite;

int main(void){

int a[]={3,4,6,7,9};

for(int i=0;i<5;i++){

s.insert(a[i]);

}

ite=s.lower_bound(4);

cout<

ite=s.upper_bound(4);

cout<

ite=s.lower_bound(8);

cout<

ite=s.upper_bound(8);

cout<

ite=s.lower_bound(9);

cout<

ite=s.upper_bound(9);

cout<

ite=s.lower_bound(99);

cout<

ite=s.upper_bound(99);

cout<

}

/*

output:

4

6

9

9

9

5

5

5

*/

map

map表示一个映射，这是非常有用的东西。其主要分为两部分表示的是一个偏序对，左边key为键值，右边value为映射值。

定义1map 名字

举个例子：

1

2

3

4map ii;

map id;

map Ld;

map ,vector > vv;

如果我们需要自定义类型的话，和前面的set一样自己定义友元函数重载运算符即可。

size函数

表示map中存储了多少对映射，时间复杂度$O( 1 )$

使用方式：

1cout<

插入方式

类似数组一样的使用方式，使用[]来进行插入。使劲按复杂度是$O(log n )$

1

2

3

4

5

6

7

8

9

10

11using namespace std;

map ma;

int main(void){

ma["a"]=3;//表示"a"映射为3

ma["b"]=312;//表示"a"映射为312

ma["c"]=43;//表示"a"映射为43

cout<

cout<

cout<

}

迭代器

使用与set一样的方式进行遍历，定义迭代器，但是相应不同的地方就是first与second的用法。其中++,—操作的时间复杂度也是$O(log n)$的。

注意，map中的end迭代器是真的没有用的。我们必须要进行特判

1

2

3

4

5

6

7

8

9

10

11

12#include

using namespace std;

map ma;

map::iterator ite;

int main(void){

ma["a"]=3;//表示"a"映射为3

ma["b"]=312;//表示"a"映射为312

ma["c"]=43;//表示"a"映射为43

for(ite=ma.begin();ite!=ma.end();ite++){

cout<first<second<

}

}

lower_bound和upper_bound函数

map在调用这些函数的时候，是二分查找键值。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17#include

using namespace std;

map ma;

map::iterator ite;

int main(void){

int i,a[]={3,4,6,7,9};

for(i=0;i<5;i++){

ma[a[i]]=i;

}

ite=ma.lower_bound(4);

if(ite!=ma.end()) cout<first<second<

ite=ma.upper_bound(4);

if(ite!=ma.end()) cout<first<second<

}

output:

4 1

6 2

vector

vector是stl中封装好的动态数组实现方式。其有一些特性，我们不妨看看。其中我们需要知道以下两个函数。

size()

capacity()

clear()

前者表示当前的vector存储了多少个数值，时间复杂度为$O(1)$，中者表示的是当前的vector申请类多少内存，后者表示清空当前的vector。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30#include

using namespace std;

vector a;

int main(void){

int i;

for(i=0;i<15;i++){

cout<

a.push_back(i);

}

a.clear();

cout<

}

/*

now size 0 now capacity 0

now size 1 now capacity 1

now size 2 now capacity 2

now size 3 now capacity 4

now size 4 now capacity 4

now size 5 now capacity 8

now size 6 now capacity 8

now size 7 now capacity 8

now size 8 now capacity 8

now size 9 now capacity 16

now size 10 now capacity 16

now size 11 now capacity 16

now size 12 now capacity 16

now size 13 now capacity 16

now size 14 now capacity 16

now size 0 now capacity 16

*/

我们运行上面的代码可以发现vector数组是倍增的，同时clear函数不会改变申请的内存的容量。

sort函数

排序的方式相对也比较简单，具体来说有几种方式。

默认的类型时使用greater方法

1

2

3

4

5

6

7

8

9

10

11

12

13

14#include

using namespace std;

vector a;

int main(void){

int i;

for(i=0;i<15;i++){

a.push_back(rand());

}

//sort(a.begin(),a.end());//增序

sort(a.begin(),a.end(),greater());//降序

for(i=0;i<15;i++){

cout<

}

}

定义cmp函数

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20#include

using namespace std;

vector a;

int cmp1(int x,int y){

return x

}

int cmp2(int x,int y){

return x>y;//降序

}

int main(void){

int i;

for(i=0;i<15;i++){

a.push_back(rand());

}

//sort(a.begin(),a.end(),cmp1);

sort(a.begin(),a.end(),cmp2);

for(i=0;i<15;i++){

cout<