STL(standard template library)

 

 

数据结构

描述

实现头文件

向量(vector)

连续存储的元素

<vector>

列表(list)

由节点组成的双向链表，每个结点包含着一个元素

<list>

双队列(deque)

连续存储的指向不同元素的指针所组成的数组

<deque>

集合(set)

由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序

<set>

多重集合(multiset)

允许存在两个次序相等的元素的集合

<set>

映射(map)

由{键，值}对组成的集合，以某种作用于键对上的谓词排列

<map>

多重映射(multimap)

允许键对有相等的次序的映射

<map>

栈(stack)

后进先出的值的排列

<stack>

队列(queue)

先进先出的值的排列

<queue>

优先队列(priority_queue)

元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列

<queue>

位集合(bitset)

Bitset是一种位集合的数据结构。使用许多二元操作符，比如逻辑和，或等。

<bitset>

字符串(string)

string 是C++中的字符串。 字符串对象是一种特殊类型的容器，专门设计来操作的字符序列。

<string>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

1、vector

v.front( )

返回对第一个元素的引用

v.back( )

返回对最后一个元素的引用

v.clear( )

清空vector

v.empty( )

如果为空，返回true，否则返回false

v.begin( )

返回指向第一个元素的迭代器（iterator）

v.end( )

返回指向最后一个元素的迭代器

v.pop_back( )

删除vector的最后一个元素

v.push_back(value)

将value放到vector的最后

v.size( )

返回vector中元素的个数

v.rbegin( )

返回指向末尾的逆向迭代器

v.rend( )

返回指向开头之前位置的逆向迭代器

v.swap(v1)

将v 和 v1交换

v.erase(loc)

v.erase(start,end)（）中的均为iterator，删除后元素前移

删除loc所指元素，并返回下一元素迭代器

删除[start, end]元素，并返回最后被删除元素的下一个迭代器

v.insert(loc,value)

v.insert(loc,num,value)

v.insert(loc,start,end)

在loc位置插入一个value 并返回其迭代器

在loc位置插入num个value

在loc位置插入[start,end)间的元素插入后元素均后移

v.erase(unique(v.begin(),v.end()), v.end()); 

v.erase(remove(v.begin(), v.end(), value),

v.end());

sort(v.begin(), v.end())//要加algorithm

对vector进行排重，

删除vector中值为value的元素

 

对vector进行从小到大排序，可加比较函数

 

 

 

 

 

 

 

 

 

 

 

2、list

L.back()

返回对最后一个元素的引用

L.front()

返回对第一个元素的引用

L.begin()

返回指向链表第一个元素的迭代器

L.end()

返回指向链表末尾的迭代器

L.rbegin()

返回一个逆向迭代器，指向链表的末尾

L.rend()

返回一个指向开头之前的逆向迭代器

L.clear()

清空链表

L.empty()

如果链表为空返回true

L.pop_back()

删除链表的最后一个元素

L.pop_front()

删除链表的第一个元素

L.push_back(val)

将val连接到链表的最后

L.push_front(val)

将val连接到链表的头部

L.remove(val)

删除表中所有值为val的元素

L.size()

返回list中元素的个数

L.unique()

去除表中重复元素（离散化）

L.reverse()

将链表元素倒转

L.sort()/L.sort(cmp)

nlog2n由小到大排序，可自定义比较函数

L.erase(pos)

L.erase(start,end)

//pos、start、end均为iterator

删除pos所指元素，并返回下一个元素迭代器

删除[start, end]间的元素，并返回下一元素的迭代器

 

L.insert(pos,val)

L.insert(pos,n,val)

//pos为iterator

插入val在pos位置，并返回其迭代器

插入n个val在pos位置

 

 

3、dequeue

d.back()

返回对最后一个元素的引用

d.front()

返回对第一个元素的引用

d.begin()

返回指向第一个元素的迭代器

d.end()

返回指向末尾的迭代器

d.rbegin()

返回一个逆向迭代器，指向链表的末尾

d.rend()

返回一个指向开头之前位置的迭代器

d.erase(pos)

d.erase(start,end)

//pos、start、end均为iterator

删除pos所指元素，并返回下一元素迭代器

删除[start,end]间的元素，并返回下一元素的迭代器

 

d.insert(pos,val)

d.insert(pos,n,val)

//pos为iterator

插入val在pos位置，并返回其迭代器

插入n个val在pos位置

 

d.pop_front()

删除第一个元素

d.pop_back()

删除最后一个元素

d.push_front(val)

将val放置到开头

d.push_back()

将val放置到最后

 

 

 

 

4、set/multiset

m.begin()

返回指向第一个元素额迭代器

m.end()

返回指向末尾元素的迭代器

m.rbegin()

返回逆向迭代器，指向链表末尾

m.rend()

返回指向开头之前位置的迭代器

m.clear()

清空迭代器

m.count(key_type key)

返回某个值元素的个数

m.empty()

如果为空，返回true

m.size()

返回元素的数量

m.swap()

交换两个集合变量

m.insert(val)

m.insert(loc,val)

m.insert(start, end);

插入val元素，并返回指向该元素的迭代器和一个布尔值来说明val是否成功的被插入了。

在迭代器loc前插入val，并返回一个指向该元素的迭代器；

将迭代器start开始到end结束返回内的元素插入到集合中；

m.erase(loc)

m.erase(start,end)

m.erase(key_type key)

删除loc所指元素

删除[start,end）之间的元素

删除key值为value的元素，并返回删除的个数

m.find(key_type key)

返回一个迭代器指向键值为key的元素，未找到返回end()

 
pair<iterator start, iterator end> equal_range(const key_type &key)

查找键值等于key的元素区间为[start, end)，指示范围的两个迭代器以pair返回

m.lower_bound(key_type key)

m.upper_bound(key_type key)

返回一个迭代器指向>=key的第一个元素

返回一个迭代器，指向>key的第一个元素

 

5、map/multimap

m.begin()

返回指向第一个元素额迭代器

m.end()

返回指向末尾元素的迭代器

m.rbegin()

返回逆向迭代器，指向链表末尾

m.rend()

返回指向开头之前位置的迭代器

m.clear()

清空迭代器

m.empty()

如果为空，返回true

m.size()

返回元素的数量

m.insert(pair<keytype,valuetype>

val)

m.insert(loc,pair<keytype,

valuetype>val)

插入pair类型元素，对map返回一个pair，first指向插入元素的迭代器，second表示插入是否成功

从loc寻找一个可以插入值为value的元素的位置并将其插入返回map

m.erase(loc)

m.erase(start,end)

m.erase(key_type key)

删除loc所指元素

删除[start,end）之间的元素

删除key值为value的元素，并返回删除的个数

m.find(key_type key)

返回一个迭代器指向键值为key的元素，未找到返回end（）

 
pair<iterator start, iterator end> equal_range(const key_type &key)

查找键值等于key的元素区间为[start, end)，指示范围的两个迭代器以pair返回

m.lower_bound(key_type key)

m.upper_bound(key_type key)

返回一个迭代器指向>=key的第一个元素

返回一个迭代器，指向>key的第一个元素

6、stack

s.empty( )

栈空返回true，否则返回false

s.pop ( )

移除堆栈中最顶层元素

s.push( )

压栈

s.size( )

返回当前栈中的元素个数

s.top( )

引用栈顶元素

 

7、queue

q.empty()

队列为空返回true

q.pop()

删除队首元素

q.size()

返回当前队列中的元素数目

q.push(val)

将val加在队尾

q.back()

返回队尾元素的引用

q.front()

返回队首元素的引用

 

8、priority_queue(一般重载运算)

Pq.empty()

优先队列为空，返回true

Pq.pop()

删除队首元素

Pq.push(val)

将val加到队尾，并排序

Pq.size()

返回当前队列中的元素数目

Pq.top()

返回队首元素的

 

9、bitset

bitset<n> b;

bitset<n> b(m);

bitset<n> b(str);

b有n位，b每一位上的值为零。

b有n位，b的初始值为m。

b有n为，b的初始值为str。(str为01组成的字符串)

操作符

!=, ==, &=, ^=, |=, ~, <<=, >>=, []

不等，相等，与，异或，或，非，左移，右移(和普通位运算一样)，取某一位(像数组)

bool test( size_t pos );

如果指定位为1返回true，否则false

bool any();

如果有位被置1返回true，否则返回false

bool none();

如果没有位被置1返回true，否则false

size_type count();

返回被设置成1的位的个数。

bitset &flip();

bitset &flip( size_t pos );

反转bitset中所有的位

反转pos上的位(pos是unsigned long)

bitset &reset();

bitset &reset( size_t pos );

置零bitset中所有的位

置零pos上的位(pos是unsigned long)

bitset &set();

bitset &set(size_t pos, int val=1);

置1 bitset中所有的位

置1 pos上的位(pos是unsigned long)

string to_string();

转换成string返回以便输出，可直接cout

 
unsigned long to_ulong();

转换成unsigned long返回.

 

10、string

void assign(start,  end );
string& assign( const char* str );
string& assign( const string& str, size_type index, size_type len );
 
赋值，[start, end)之间的元素
赋值，用字符数组
赋值，用string 从index开始的最多len个字符
 
const char * c_str();
 
返回一个标准c字符串，但是不允许修改，否则会破坏string的内部结构
 
iterator erase( iterator loc );
iterator erase( iterator start, iterator end );
string& erase( size_type index = 0, size_type  num = npos );
 
删除loc位置的字符
删除[start,end)之间的字符
删除从index开始的num个字符，返回*this
 
size_type find( const string& str, size_type index );
size_type find( const char* str, size_type index );
size_type find( const char* str, size_type index, size_type length );
size_type find( char ch, size_type index );
 
返回从index开始str第一次出现的位置，找不到就返回string::npos(常量)
返回从index开始str第一次出现的位置，找不到就返回string::npos(常量)
返回从index开始str前length个字符第一次出现的位置，找不到就返回string::npos(常量)
返回从index开始，字符ch第一次出现的位置，找不到就返回string::npos
 
find_first_of
 
格式同find，返回第一个是给定的字符串串中字符的位置
 
find_last_of
 
格式同同find，反向查找，返回第一个是给定的字符串串中字符的位置
 
iterator insert( iterator i, const char& ch );
string& insert( size_type index, const string& str );

iterator insert( iterator i, const char &ch );

  basic_string &insert( size_type index, const basic_string &str );

  basic_string &insert( size_type index, const char *str );

  basic_string &insert( size_type index1, const basic_string &str, size_type index2, size_type num );

  basic_string &insert( size_type index, const char *str, size_type num );

  basic_string &insert( size_type index, size_type num, char ch );

  void insert( iterator i, size_type num, const char &ch );

  void insert( iterator i, iterator start, iterator end );

 
在迭代器i指向的位置插入一个字符ch
在位置index插入一个string
在迭代器i表示的位置前面插入一个字符ch, 
在字符串的位置index插入字符串str, 在字符串的位置index插入字符串str的子串(从index2开始，长num个字符), 在字符串的位置index插入字符串str的num个字符, 
在字符串的位置index插入num个字符ch的拷贝, 
在迭代器i表示的位置前面插入num个字符ch的拷贝, 
在迭代器i表示的位置前面插入一段字符，从start开始，以end结束.
 
void push_back(char &c)
 
插入字符c到string的末尾
 
size_type size();
 
返回字符串中现有字符的个数
 
string substr( size_type index, size_type length = npos );
 
返回包含从index的最多length个字符的string，不指定length就到结尾