数据结构与基础算法——STL库（容器与容器适配器篇）

原创于 2025-12-03 21:43:06 发布 · 374 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言 #STL #数据结构 #算法

数据结构与算法专栏收录该内容

3 篇文章

订阅专栏

无序键值对集合（unordered_map）

C++ STL库方便去实现数据结构与算法，这边来讲解一些常用的组件，为后面学习做铺垫。

万能头：

#include <bits/stdc++.h>
using namespace std;

容器（Containers）

容器是用来存储数据的序列，它们提供了不同的存储方式和访问模式。

序列容器

存储元素的序列，允许双向遍历。

动态数组（vector）

vector支持快速随机访问。

/*创建vector*/
vector<int> myVector;
vector<int> myVector(5); //每个值默认为0
vector<int> myVector(5, 10);

/*添加元素*/
myVector.push_back(7); //添加到末尾

/*删除元素*/
myVector.pop_back(); //删除最后一个元素

/*访问元素*/
int x = myVector[0];
int y = myVector.at(1);
int first = myVector.front() //返回第一个元素
int last = myVector.back() //返回最后一个元素

/*获取大小*/
int size = myVector.size();

/*清空元素*/
myVector.clear();

双端队列（deque）

deque支持快速插入和删除。

/*声明deque*/
deque<int> dq;

/*访问元素*/
int pos = dq[index];
int front = dq.front(); //返回队首
int back = dq.back(); //返回队尾

/*添加元素*/
dq.push_back(10); //末尾添加
dq.push_front(20); //头部添加

/*删除元素*/
dq.pop_back(); //移除末尾元素
dq.pop_front(); //移除头部元素

/*获取长度*/
int size = dq.size();

/*判断是否为空*/
bool flag = dq.empty();

双向链表（list）

list链表，支持快速插入和删除，但不支持随机访问。

/*声明list*/
list<int> l;
//初始化和vector一样

/*访问元素*/
int front = l.front();
int last = l.back();

/*添加元素、删除元素、获取长度、判断是否为空*/
//同deque常用操作一样

/*合并list*/
l1.merge(l2);

/*反转list*/
l.reverse();

关联容器

存储键值对，每个元素都有一个键（key）和一个值（value），并且通过键来组织元素。

有序集合（set）

set集合，不允许重复元素。

/*声明set*/
//不重复且有序
set<int> s;

/*添加元素*/
s.insert(10);
s.insert({20, 30, 40}); //插入多个元素

/*查找元素*/
//count()实际上是计数作用，但由于set中元素不重复，即 0 表示不存在，1 表示存在
bool flag = s.count(10); 

if (s.find(10) != s.end()) {
	//存在
}

/*判断是为空*/
bool isEmpty = s.empty();

/*删除元素*/
s.erase(10);

/*清空元素*/
s.clear();

键值对集合（map）

map映射，每个键映射到一个值。

/*声明map*/
map<string, int> mp;
//可以自定义排序(默认为升序)
map<string, int, greater<string>> mp; //降序

/*访问元素*/
int days = mp["January"]; 

/*添加元素*/
mp.insert(make_pair("February", 28));
mp.insert({"March", 31});
mp["April"] = 31;

/*删除元素*/
mp.erase("April");

/*清空元素*/
mp.clear();

/*判断元素*/
bool flag1 = mp.empty(); //map是否为空
bool flag2 = mp.count("April"); //"April"(key)是否存在
if (mp.find("April") != mp.end()) {
	//键存在
}

无序关联容器

哈希表，支持快速的查找、插入和删除。

无序集合（unordered_set）

unordered_set无序集合。

/*声明unordered_set*/
//不重复但无序
unordered_set<int> uset;

//其它的操作与set是一样的

无序键值对集合（unordered_map）

unordered_map无序映射。

/*声明unordered_map*/
//无序
unordered_map<int, int> ump;

//其它操作与map是一样的

map与unordered_map对比

map

优：内部用红黑树实现，内部元素具有有序性，查询删除等操作复杂度为O(logN)
缺：占用空间，红黑树里每个节点需要保存父子节点和红黑性质等信息，空间占用较大

unordered_map

优：内部用哈希表实现，查找速度非常快（适用于大量的查询操作）
缺：建立哈希表比较耗时

容器适配器（Adapters）

容器适配器是一种特殊容器，它们通过封装其他序列式容器（如vector、deque和list）来提供特定的功能。

容器适配器的作用类似于电源适配器，将不适用的电源转换为适用的电源。

栈（stack）

stack是一种后进先出（LIFO）的数据结构。它只允许在一端插入和删除元素。stack适配器的底层容器可以是vector、deque或list。

/*声明stack*/
stack<int> s;

/*添加元素*/
s.push(1);
s.push(2);
s.push(3);

/*访问栈顶元素*/
int top = s.top();

/*移除栈顶元素*/
s.pop();

/*检查栈是否为空*/
bool flag = s.empty();

队列（queue）

queue是一种先进先出（FIFO）的数据结构。它允许在一端插入元素，在另一端删除元素。queue适配器的底层容器可以是deque或list。

/*声明queue*/
queue<int> q;

/*添加元素*/
q.push(10);
q.emplace(10);

/*访问元素*/
int front = q.front(); //返回队首元素
int back = q.back(); //返回队尾元素

/*移除队首元素*/
q.pop();

/*获取队列长度*/
int size = q.size();

/*判断队列是否为空*/
bool flag = q.empty();

有序队列（priority_queue）

priority_queue是一种优先级队列，元素按照优先级排序。默认情况下，优先级最高的元素最先出队。priority_queue适配器的底层容器可以是vector或deque。

/*声明priority_queue*/
//priority_queue默认是一个最大堆(降序排序)
priority_queue<int> pq;

//priority_queue<Type, Container, Functional>
//Type-元素类型,Container-必须使用数组实现的容器(如deque,vector),Functional是要实现的排序规则(可以自定义比较函数)
priority_queue<int, vector<int>, greater<int>> pq; //升序排序
priority_queue<int, vector<int>, less<int>> pq; //降序排序

//自定义排序
struct compare {
	bool operator()(int a, int b) {
		return a > b;
	}
}
priority_queue<int, vector<int>, compare> pq;

/*添加元素*/
q.push(10);

/*访问元素*/
int front = pq.top(); //返回队首元素

/*移除队首元素*/
q.pop();

/*获取队列长度*/
int size = q.size();

/*判断队列是否为空*/
bool flag = q.empty();

大家写算法题的时候可以多用用这些容器。

ps：给博主点个免费的关注，后面将持续更新数据结构与算法以及其它计算机相关知识。