【C++】STL

所念非欢

已于 2022-07-31 19:16:21 修改

阅读量295

点赞数

分类专栏： C++ 文章标签： c++ 数据结构算法

于 2022-07-31 19:08:52 首次发布

本文链接：https://blog.csdn.net/m0_61357071/article/details/126089222

版权

C++ 专栏收录该内容

14 篇文章 2 订阅

订阅专栏

1.stack（栈）

先进后出的数据结构。

栈只允许访问栈顶元素，不允许随机访问和遍历。

常用接口：
0. 头文件
#include <stack>

构造函数
- stack stk;
- stack stk2(stk1);
赋值操作
- (stack) stk2 = (stack) stk1;
数据存取
- push(T data) : 入栈
- pop() : 出（弹）栈
- top() : 返回栈顶元素
获取属性
- empty() : 判断是否为空，为空返回true
- size() : 返回栈的大小

2.queue（队列）

先进先出的数据结构。

队列只允许访问队头数据和队尾元素，存数据只能是队尾。

不允许随机访问和遍历。

常用接口：
0. 头文件
#include <queue>

构造函数
- queue que;
- queue que2(que1);
赋值操作
- (queue) que2 = (queue) que1;
数据存取
- push(T data) : 入队（尾）
- pop() : 出队（头）
- back() : 返回最后一个元素
- front() : 返回队头元素
获取属性
- empty();
- size();

3.list（链表）

将数据链式存储的一种数据结构。

一个数据结点由一个数据域和指针域构成。

单向链表：（一个）数据域用来存储数据，（一个）指针域用来存储下一结点的数据域地址。

优点：

对任一位置数据进行快速的插入，删除。
利用了较为零散的空间
缺点：
查找，遍历时较为费时
无法回溯访问
较为占用空间

针对第二个缺点，定义双向链表：（一个）数据域用来存储数据，（两个个）其中，一个指针域用来存储下一结点的数据域地址，另外一个指针域指向上一结点的数据域。

常用接口：
0. 头文件：
#include <list>

构造函数：
- list list1;
- list list2(list::iterator it1, list::iterator it2);
- list list1(int n, T data);
- list list2(list1);
赋值和交换：
- (list) list2.assign(list::iterator it1, list::iterator it2);
- (list) list1.assign(int n, T data);
- (list) list2 = (list) list1;
- (list) list2.swap((list) list1);
获取属性：
- list.size();
- list.empty();
- list.resize(int num);
- list.resize(int num, T data);
插入和删除：
- list.push_back(T data);
- list.push_front(T data);
- list.pop_back();
- list.pop_front();
- list.insert(iterator pos, T data) : 在位置pos处插入数据data
- list.insert(iterator pos, int n, T data) : 在位置pos处插入n个数据data
- list.insert(iterator pos, iterator it1, iterator it2);
- list.clear();
- list.erase(iterator it1, iterator it2) : 删除区间内所有数据，返回下一结点数据域地址
- list.pos(iterator pos) : 删除pos结点的数据，返回下一结点数据域地址
- list.remove(T data) : 移除链表中所有的data
数据的存取：
- list.front() : 返回第一个元素
- list.back() : 返回最后一个元素
链表反转：
- list.reverse() : 链表反转
- list.sort() : 链表升序排序
  注意：
  - 标准算法头文件中的算法只适用于支持随机访问的容器，调用时，使用函数的调用形式
  - 对于不支持随机访问的容器，其内部实现了部分算法，使用时，使用方法的调用形式

4.set&multiset（集合）

在插入数据时自动排序，默认升序排列，想改变排序方法可以使用仿函数实现。

关联式容器，底层数据结构使用二叉树实现。

set不允许数据重复出现，multiset允许。

常用接口：
0. 头文件

构造和初始化：
- set s1;
- set s2(s1);
- (set) s2 = (set s1);
获取属性：
- set.size();
- set.empty();
交换数据：
- set1.swap(set2);
插入和删除：
- set.insert(T data);
- set.clear();
- set.erase(iterator pos);
- set.erase(iterator it1, iterator it2);
- set.erase(T data) : 删除所有匹配项
查找和统计：
- set.find(T data) : 从容器中查找数据data，找到返回迭代器位置，未找到返回end()
- set.count(T data) : 统计set中data的个数

值得注意的是，set容器对于自定义的数据类型无法进行直接排序，需要通过仿函数对排序规则进行指定。

class myCompare
{
public:
   bool operator()(class_name c1, class_name c2)const
   {
      // 排序规则
   }
};

5.pari（对组or元组）

成对出现的数据可以使用元组来存储。

底层使用结构体实现。

使用不需要刻意引入头文件。

常用接口：

定义方式：
- pari<T1, T2> p(T1 data1, T2 data2);
- pari<T1, T2> p = make_pari((T1)data1, (T2)data2);
数据访问：
- pari.first : 访问第一个数据
- pari.second : 访问第二个数据

6.map&multimap（字典）

map中所有的元素均为pari，first为关键字key，也称索引值，键值，second为实值value。且所有元素在插入时根据key自动排序（默认升序）。

map也属于关联式容器，底层数据结构为二叉树。

索引不可以重复，但是值可以。

常用方法：
0. 头文件

#include <map>

构造和赋值：
- map<T1, T2> mp;
- map<T1, T2> mp2(mp1);
- mp1 = mp2;
属性的获取：
- map.size();
- map.empty();
- map1.swap(map2);
插入和删除：
- map.insert(pari<T1, T2> (key, value));
- map.insert(make_pari((T1)key, (T2)value));
- map.insert(map<T1, T2>::valve_type(key, value));
- map[key] = vlaue; // 这种方式不建议在访问数据元素使用，避免覆盖原值，或者生成一个不存在的键值对。
- map.clear();
- map.erase(iterator pos);
- map.erase(iterator it1, iterator it2);
- map.erase((T1) key) : 删除索引值为key的键值对，对于multimap而言，则会删除所有匹配项