STL速查手册

Villanelle#

已于 2022-03-04 23:16:24 修改

阅读量1.2k

点赞数

分类专栏：算法文章标签： leetcode c++

于 2022-03-04 23:15:29 首次发布

本文链接：https://blog.csdn.net/qq_42990969/article/details/123287279

版权

算法专栏收录该内容

16 篇文章 0 订阅

订阅专栏

STL- 八大容器及其常用方法整理

1 string 容器

注：此处所列函数原型const string &s均可替换为const char *s。

1.1 string 构造函数

string(); //创建一个空的字符串例如: string str;
string(const char* s); //使用字符串s初始化
string(const string& str); //拷贝构造

1.2 string 赋值操作

string& operator=(const string &s); //把字符串s赋给当前的字符串

1.3 string 字符串拼接

string& operator+=(const string& str); //重载+=操作符
string& append(const string &s); //同operator+=(const string& str)

1.4 string 查找和替换

find和rfind方法找不到返回-1。

int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str

1.5 string 字符串比较

比较方式：按字符的ASCII码进行对比，主要用于比较两个字符串是否相同，相同则返回0。

int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较

1.6 string 字符存取

char& operator[](int n); //通过[]方式取字符
char& at(int n); //通过at方法获取字符

1.7 string 插入和删除

string& insert(int pos, const string& str); //插入字符串
string& erase(int pos, int n = npos); //删除从Pos开始的n个字符

1.8 string 子串

string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串

2 vector 容器(动态扩展的数组)

2.1 vector 构造函数

vector<T> v; //采用模板实现类实现，默认构造函数
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。

2.2 vector 赋值和交换

vector& operator=(const vector &vec);//重载等号操作符
swap(vec); // 将vec与本身的元素互换，可用于收缩内存vector<int>(v).swap(v); //匿名对象

2.3 vector 容量和大小

empty(); //判断容器是否为空
capacity(); //容器的容量
size(); //返回容器中元素的个数
resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除

2.4 vector 插入和删除

push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
erase(const_iterator pos); //删除迭代器指向的元素
clear(); //删除容器中所有元素

2.5 vector 数据存取

at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

2.6 vector 预留空间

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问，数据量较大时可用于减少vector在动态扩展容量时的扩展次数。

3 deque 容器(双端数组)

3.1 deque 构造函数(同vector)

deque<T> deq; //默认构造形式
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq); //拷贝构造函数

3.2 deque 赋值和交换(同vector)

deque& operator=(const deque &deq); //重载等号操作符
swap(deq); //将deq与本身的元素互换

3.3 deque 大小操作(与vector相比无capacity)

deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。

3.4 deque 插入和删除(比vector多了头部的操作)

push_back(elem); //在容器尾部添加一个数据
push_front(elem); //在容器头部插入一个数据
pop_back(); //删除容器最后一个数据
pop_front(); //删除容器第一个数据
insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位
clear(); //清空容器的所有数据
erase(pos); //删除pos位置的数据，返回下一个数据的位置

3.5 deque 数据存取(同vector)

at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

4 stack 容器(堆栈)

4.1 stack 构造函数

stack<T> stk; //stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数

4.2 stack 赋值和交换

stack& operator=(const stack &stk); //重载等号操作符
swap(stk); //将stk与本身的元素互换

4.3 stack 大小操作

empty(); //判断堆栈是否为空
size(); //返回栈的大小

4.4 stack 插入和删除

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素

4.5 stack 数据存取

top(); //返回栈顶元素

5 queue 容器(队列)

5.1 queue 构造函数

queue<T> que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数

5.2 queue 赋值和交换

queue& operator=(const queue &que); //重载等号操作符
swap(que); //将que与本身的元素互换

5.3 queue 大小操作

empty(); //判断堆栈是否为空
size(); //返回栈的大小

5.4 queue 插入和删除

push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素

5.5 queue 数据存取

back(); //返回最后一个元素
front(); //返回第一个元素

6 list 容器(双向循环链表)

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

6.1 list 构造函数

list<T> lst; //list采用采用模板类实现,对象的默认构造形式：
list(n,elem); //构造函数将n个elem拷贝给本身。
list(const list &lst); //拷贝构造函数。

6.2 list 赋值和交换

list& operator=(const list &lst); //重载等号操作符
swap(lst); //将lst与本身的元素互换。

6.3 list 大小操作

size(); //返回容器中元素的个数
empty(); //判断容器是否为空
resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
```
  				    //如果容器变短，则末尾超出容器长度的元素被删除。
```

6.4 list 插入删除

push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
clear();//移除容器的所有数据
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。

6.5 list 数据存取

front(); //返回第一个元素。
back(); //返回最后一个元素。

6.6 list 反转和排序(成员函数)

reverse(); //反转链表
sort(); //链表排序
sort(MyCompare); //使用仿函数自定义排序规则

class MyCompare 
{
    public:
    bool operator()(int v1, int v2) {
        return v1 > v2; //升序
    }
};

sort(ComparePerson); //若list存放自定义数据类型，排序时必须指定排序规则

bool ComparePerson(Person& p1, Person& p2) {
    if (p1.m_Age == p2.m_Age) {
        return p1.m_Height  > p2.m_Height; //如果年龄相同按照身高降序
    }
    else{
        return  p1.m_Age < p2.m_Age; //按照年龄进行升序
    }
}

7 set/multiset 容器(集合/允许重复集合)

7.1 set 构造函数

set<T> st; //默认构造函数：
set(const set &st); //拷贝构造函数

7.2 set 赋值和交换

set& operator=(const set &st); //重载等号操作符
swap(st); //交换两个集合容器

7.3 set 大小操作

size(); //返回容器中元素的数目
empty(); //判断容器是否为空

7.4 set 插入和删除

insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(elem); //删除容器中值为elem的元素。

7.5 set 查找和统计

find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数(对于set结果为0或1)

7.6 set和multiset区别

set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入是否成功
multiset不会检测数据，因此可以插入重复数据

7.7 set 容器排序

插入元素时自动排序，默认为从小到大，可在定义容器时使用仿函数自定义排序规则。

set<int, MyCompare> s; //Mycompare是自定义的类，类内重载了()(谓词)

class MyCompare 
{
    public:
    bool operator()(int v1, int v2) {
    return v1 > v2; //升序
    }
};

set<Person, comparePerson> s; //set存放自定义数据类型，必须指定排序规则

bool ComparePerson(Person& p1, Person& p2) {
    if (p1.m_Age == p2.m_Age) {
        return p1.m_Height  > p2.m_Height; //如果年龄相同按照身高降序
    }
    else{
        return  p1.m_Age < p2.m_Age; //按照年龄进行升序
    }
}