e2hang/Data-Structure
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New Stage

Browse Source
This commit is contained in:
e2hang
2025-08-06 18:43:00 +08:00
parent b4c8ed60a9
commit dce2cea131
4 changed files with 754 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
STL/README.MD Normal file
View File

@@ -0,0 +1,94 @@
```cpp
C++ STL（Standard Template Library）
├── 容器 Containers
│ ├── 顺序容器（Sequence containers）
│ │ ├── vector
│ │ ├── deque
│ │ ├── list
│ │ ├── forward_list
│ │ ├── array
│ │ └── string（非正式容器）
│ ├── 关联容器（Associative containers）【红黑树】
│ │ ├── set
│ │ ├── multiset
│ │ ├── map
│ │ └── multimap
│ ├── 无序容器（Unordered containers）【哈希表】
│ │ ├── unordered_set
│ │ ├── unordered_multiset
│ │ ├── unordered_map
│ │ └── unordered_multimap
│ └── 容器适配器（Container adapters）
│ ├── stack
│ ├── queue
│ └── priority_queue
│
├── 算法 Algorithms
│ ├── 非变序算法（不修改元素）
│ │ ├── for_each
│ │ ├── count, count_if
│ │ ├── find, find_if, find_if_not
│ │ ├── all_of, any_of, none_of
│ │ ├── min_element, max_element
│ ├── 变序算法（会修改序列）
│ │ ├── sort, stable_sort, partial_sort
│ │ ├── reverse, rotate
│ │ ├── copy, move, swap
│ │ ├── remove, unique
│ │ ├── transform
│ ├── 排列组合相关
│ │ ├── next_permutation
│ │ ├── prev_permutation
│ │ ├── is_permutation
│ ├── 归并、集合操作
│ │ ├── merge
│ │ ├── includes
│ │ ├── set_union, set_intersection
│ │ ├── set_difference, set_symmetric_difference
│ └── 数值算法
│ ├── accumulate
│ ├── inner_product
│ ├── adjacent_difference
│ └── partial_sum
│
├── 迭代器 Iterators
│ ├── 输入迭代器 InputIterator
│ ├── 输出迭代器 OutputIterator
│ ├── 前向迭代器 ForwardIterator
│ ├── 双向迭代器 BidirectionalIterator
│ ├── 随机访问迭代器 RandomAccessIterator
│ └── 常用工具
│ ├── begin(), end()
│ ├── rbegin(), rend()
│ ├── back_inserter(), inserter()
│ └── advance(), distance(), next(), prev()
│
├── 函数对象 Function Objects（仿函数 Functors）
│ ├── plus, minus, multiplies, divides, modulus
│ ├── equal_to, not_equal_to, greater, less, greater_equal, less_equal
│ ├── logical_and, logical_or, logical_not
│ ├── bind, bind1st, bind2nd（C++11 前）
│ └── lambda 表达式（C++11 起替代大部分）
│
├── 分配器 Allocators（内存管理器）
│ ├── std::allocator（默认分配器）
│ ├── 可以自定义自己的 allocator（进阶用法）
│
├── 配接器（Adapters）
│ ├── 容器适配器：stack, queue, priority_queue（见容器）
│ ├── 函数适配器：bind、function、mem_fn、not1、not2
│ ├── 迭代器适配器：reverse_iterator, insert_iterator 等
│
├── 实用组件 Utilities
│ ├── pair（std::pair、make_pair）
│ ├── tuple（C++11）
│ ├── optional（C++17）
│ ├── variant（C++17）
│ ├── any（C++17）
│ ├── bitset
│ ├── chrono（时间库）
│ ├── ratio（比例）
│ ├── type_traits（模板元编程工具）
│ ├── numeric_limits
│ └── initializer_list（支持 `vector<int> v = {1,2,3}`）
```

206
STL/STL-Set/README.MD Normal file
View File

@@ -0,0 +1,206 @@
当然可以！以下是 **C++ STL 中 `set` 的详细介绍和使用方法大全**，包括：
---
## 🧱 1. 基本概念
`std::set` 是一个 **有序集合**，底层实现是 **红黑树（RB-tree）**。
特点如下：
* 所有元素 **自动升序排列（默认 `<`）**
* 所有元素 **唯一**，不能重复
* 元素类型必须支持 `<` 操作符（可自定义）
* **查找、插入、删除**操作都是 **O(log n)** 的时间复杂度
---
## 📦 2. 头文件
```cpp
#include <set>
```
---
## 🧪 3. 声明与初始化
```cpp
std::set<int> s1; // 空集合
std::set<int> s2 = {4, 1, 3}; // 初始化，自动排序去重
std::set<std::string> s3{"apple", "banana"};
std::set<int, std::greater<int>> s4; // 降序排列
```
---
## 🧾 4. 常用成员函数汇总
| 函数 | 作用 |
| ------------------ | -------------------------------- |
| `insert(val)` | 插入元素（成功返回 pair\<iterator, true>） |
| `emplace(val)` | 就地构造元素，性能比 `insert` 更高 |
| `find(val)` | 返回指向该元素的迭代器，找不到返回 `end()` |
| `count(val)` | 返回该值的数量（对于 set 只能是 0 或 1） |
| `erase(val)` | 删除指定元素 |
| `erase(it)` | 删除指定迭代器处元素 |
| `clear()` | 清空集合 |
| `size()` | 元素个数 |
| `empty()` | 是否为空 |
| `begin(), end()` | 起始、结束迭代器 |
| `lower_bound(val)` | 第一个 `>= val` 的位置 |
| `upper_bound(val)` | 第一个 `> val` 的位置 |
| `equal_range(val)` | 返回一个 pair，表示 `[lower, upper)` 区间 |
---
## 🔨 5. 插入与查找示例
```cpp
std::set<int> s;
s.insert(5);
s.insert(3);
s.insert(8);
s.insert(3); // 自动忽略重复
// 查找
if (s.find(3) != s.end()) {
std::cout << "Found 3\n";
}
// 遍历
for (int x : s)
std::cout << x << " "; // 输出：3 5 8
```
---
## ⛏ 6. 删除元素
```cpp
s.erase(5); // 删除值为5的元素
auto it = s.find(8);
if (it != s.end()) s.erase(it); // 用迭代器删除
```
---
## ⏬ 7. 自定义排序规则
```cpp
struct MyCmp {
bool operator()(const int &a, const int &b) const {
return a > b; // 降序
}
};
std::set<int, MyCmp> s = {1, 5, 3}; // 输出顺序：5 3 1
```
---
## 🌈 8. 自定义结构体作为元素
### ✅ 正确写法：重载 `<`
```cpp
struct Person {
std::string name;
int age;
bool operator<(const Person &other) const {
return age < other.age; // 按 age 排序
}
};
std::set<Person> people;
people.insert({"Tom", 25});
people.insert({"Jerry", 20});
```
---
## 🔄 9. 遍历方式
```cpp
// 方法1：范围 for
for (int x : s) std::cout << x << " ";
// 方法2：迭代器
for (auto it = s.begin(); it != s.end(); ++it)
std::cout << *it << " ";
```
---
## 🧵 10. lower\_bound / upper\_bound 示例
```cpp
std::set<int> s = {2, 4, 6, 8};
auto lb = s.lower_bound(5); // 指向6
auto ub = s.upper_bound(6); // 指向8
```
---
## 🪄 11. set 和 multiset 区别
| 容器 | 是否允许重复 | 底层实现 |
| ---------- | ------- | ---- |
| `set` | ❌ 不允许重复 | 红黑树 |
| `multiset` | ✅ 允许重复 | 红黑树 |
---
## 📚 12. 常见用法技巧
### 用 set 去重：
```cpp
std::vector<int> v = {1, 2, 2, 3};
std::set<int> s(v.begin(), v.end()); // 自动去重
```
### 用 set 排序：
```cpp
std::set<int> s = {5, 1, 3};
// 自动升序排列：1 3 5
```
### 交换两个 set：
```cpp
std::set<int> a = {1, 2};
std::set<int> b = {3, 4};
a.swap(b);
```
---
## 🧮 13. 高级操作（C++17 起）
```cpp
if (auto [it, ok] = s.insert(10); ok) {
std::cout << "插入成功：" << *it << "\n";
}
```
---
## 🚨 14. 注意事项
* `insert` 不会覆盖已有元素，若想更新值，请先 `erase()` 再 `insert()`
* 遍历时 **不要修改元素值**（因为会破坏红黑树结构）
* `set` 的 `[]` 操作符不存在（不同于 `map`）
---
如需，我还可以为你提供：
* 📘 set 应用实战代码示例
* 🧠 使用场景解析（如 top-k、排名、自动去重等）
* 🧩 `unordered_set` 的比较与选择策略
是否要我继续讲 `multiset` 和 `unordered_set`？

242
std/PATH.MD Normal file
View File

@@ -0,0 +1,242 @@
学完 `std`，你基本上已经掌握了 C++ 标准库的核心内容。但如果你想系统地掌握 C++，不仅仅是 `std`，还包括以下几个大的模块/主题：
---
### ✅ 一、C++ 标准库（Standard Library）
这是你正在学的内容，包括：
#### 1. STL（Standard Template Library）💡
* 容器（`vector`, `list`, `map`, `set`, …）
* 算法（`sort`, `find`, `for_each`, …）
* 迭代器（`iterator`, `reverse_iterator`, …）
* 函数对象（`std::less`, `std::greater`, …）
* 配接器（`stack`, `queue`, `priority_queue`）
* 分配器（了解即可）
#### 2. 其他 std 模块 ✨
* 智能指针（`shared_ptr`, `unique_ptr`, `weak_ptr`）
* 时间库（`<chrono>`）
* 文件和 IO 流（`<fstream>`, `<iostream>`, `<sstream>`）
* 字符串处理（`std::string`, `std::string_view`, …）
* 正则表达式（`<regex>`）
* 并发支持（`<thread>`, `std::mutex`, `std::atomic`, …）
* 错误处理（异常 `try/catch`, `<stdexcept>`, `error_code`）
* 数值库（`<cmath>`, `<numeric>`, `<random>`）
* 元编程和类型特性（`<type_traits>`, `std::enable_if`, `std::is_same` 等）
---
### ✅ 二、C++ 语言特性（不是库，是语法层面的东西）
* 基本语法（变量、函数、控制流）
* 面向对象（类、继承、多态、虚函数）
* 模板（函数模板、类模板、模板特化、SFINAE）
* Lambda 表达式
* 异常处理（`try-catch`）
* 引用、指针、智能指针
* constexpr、auto、decltype、range-based for、结构化绑定（C++17）
* 类型推导与 `decltype(auto)`
* Rvalue 引用和移动语义（C++11+）
* 协程（C++20）
---
### ✅ 三、现代 C++ 标准版本
* C++98/03：经典 STL
* C++11：智能指针、`auto`、`nullptr`、Lambda、`std::thread`
* C++14：泛型 Lambda、返回类型推导
* C++17：结构化绑定、`if constexpr`、`std::optional`
* C++20：协程、concepts、ranges、`std::format`
* C++23：`std::expected`, `std::mdspan`, 模块化初步
---
### ✅ 四、第三方库（超越 std 的工具）
虽然不是 `std`，但你之后可以学：
* Boost（准标准库，很多后来被 C++ 标准采纳）
* fmt（现代格式化库，比 `printf` 和 `std::cout` 更强）
* spdlog（日志库）
* Eigen / Armadillo（矩阵运算）
* Qt（GUI 和跨平台开发）
* OpenCV（图像处理）
* JSON for Modern C++（`nlohmann::json`）
---
### ✅ 五、其他知识
* 构建工具（CMake）
* 编译过程和链接过程
* 单元测试（如 Google Test）
* 性能优化（内存、CPU、并发）
* 调试技巧（GDB, Valgrind, Visual Studio 等）
---
### ✅ 六、实战项目建议
* 数据结构与算法练习（如 LeetCode）
* 实现一个简单的 web server（理解并发）
* 编写一个图形界面工具（用 Qt）
* 实现一个简易数据库（理解数据结构、文件操作）
* 游戏开发小项目
---
如果你想，我可以为你规划一个完整的学习路径，从 `std` 到现代 C++ 实战。是否需要？
很好，我们将为你规划一个从 `std` 到现代 C++ 实战的**完整学习路径**。这个路径将涵盖：
1. C++ 标准库（`std`）
2. 现代 C++ 特性（C++11\~C++23）
3. 实战技能与项目能力提升
4. 与操作系统、硬件、网络等系统知识的衔接（进阶）
5. 职业级开发者所需的软/硬技能
---
## 🧭 阶段 1：掌握 C++ 标准库（`std`）
### 1. 容器（Containers）
* 顺序容器：`vector`, `deque`, `list`, `array`, `forward_list`
* 关联容器：`set`, `multiset`, `map`, `multimap`
* 无序关联容器：`unordered_set`, `unordered_multiset`, `unordered_map`, `unordered_multimap`
* 容器适配器：`stack`, `queue`, `priority_queue`
### 2. 迭代器（Iterators）
* 输入、输出、前向、双向、随机访问迭代器
* `iterator_traits`, `reverse_iterator`, `insert_iterator` 等适配器
* `begin()`, `end()`, `rbegin()`, `rend()`
### 3. 算法（<algorithm> 与 <numeric>）
* 非变异算法：`find`, `count`, `all_of`, `any_of`, `none_of` 等
* 变异算法：`sort`, `reverse`, `rotate`, `partition`, `unique` 等
* 数值算法：`accumulate`, `inner_product`, `iota` 等
### 4. 函数对象与 Lambda
* `std::function`, `std::bind`, `std::ref`
* lambda 表达式捕获、泛型 lambda
* 比较器、自定义函数对象
### 5. 字符串与字符串流
* `std::string`, `std::wstring`
* `std::stringstream`, `std::ostringstream`, `std::istringstream`
### 6. 时间与日期（<chrono>）
* `std::chrono::duration`, `system_clock`, `steady_clock`
* `sleep_for`, `sleep_until`
### 7. 智能指针
* `std::unique_ptr`, `std::shared_ptr`, `std::weak_ptr`
* `make_unique`, `make_shared`
### 8. 输入输出（<iostream>）
* `std::cin`, `std::cout`, `std::cerr`, `std::getline`
* 文件 I/O: `<fstream>`
### 9. 异常处理
* `try`, `catch`, `throw`
* `std::exception`, 自定义异常类
### 10. 其他有用工具
* `<tuple>`, `<pair>`, `<optional>`, `<variant>`
* `<bitset>`, `<array>`, `<any>`, `<stacktrace>`, `<source_location>`
* `<memory>`, `<type_traits>`, `<limits>`, `<functional>`, `<utility>`
---
## 🚀 阶段 2：现代 C++（C++11 - C++23）
### 1. C++11
* `auto`, `nullptr`, `enum class`
* 右值引用与移动语义
* `std::thread`, `std::mutex`, `std::atomic`
* `lambda`, `range-based for`, `initializer_list`
* `constexpr`, `static_assert`
### 2. C++14
* 泛型 lambda（auto 参数）
* `std::make_unique`
* 二进制字面量、返回类型推导（`auto f() -> int`）
### 3. C++17
* `std::optional`, `std::variant`, `std::string_view`
* if constexpr, structured bindings (`auto [a, b] = ...`)
* 内联变量 `inline static`
### 4. C++20
* 协程（`co_await`, `co_yield`, `co_return`）
* ranges 库：`std::ranges::views::filter`, `transform`
* 概念（Concepts）：`requires`
* 模块化支持、三向比较 `<=>`
### 5. C++23
* `std::expected`, `mdspan`, `stacktrace`, `std::print`
* 扩展的 ranges 和协程支持
* 模块进一步优化
---
## 🧪 阶段 3：C++ 实战能力构建
### 小项目建议
* 学生管理系统（用 map 和 vector 实现）
* 快速文件搜索器（使用 unordered\_map 和正则表达式）
* 图形化贪吃蛇（用 SDL + C++）
* 简易 Web 服务器（socket + 多线程）
### 实战技能
* **调试**：GDB、Visual Studio Debug、Valgrind
* **构建系统**：Makefile, CMake
* **测试框架**：GoogleTest, Catch2
* **性能分析**：perf, gprof, cppcheck
* **代码风格**：ClangFormat, Git + Lint
---
## 🧱 阶段 4：系统层知识融合（进阶）
* **操作系统原理**
* **内存管理 / 虚拟内存**
* **线程、协程与并发模型**
* **计算机网络（Socket、HTTP 协议）**
* **C++ 与汇编互操作（内联汇编）**
* **现代架构与设计模式（SOLID、MVC）**
---
## 🧑‍💻 阶段 5：面向职业开发
* 项目经验 + 开源贡献（GitHub）
* LeetCode、牛客刷题（加强算法）
* 简历准备 + 面试训练
* 学习 Rust/Go/Python 等现代语言进行对比
---
如果你希望，我可以按这个路径，逐阶段为你布置学习计划，每一阶段配上知识点 + 练习 + 小项目，帮助你掌握并实践。
是否希望我从【阶段 1：std 学习计划】开始布置？

212
std/README.MD Normal file
View File

@@ -0,0 +1,212 @@
好的！下面是一份全面的《🚀C++17/C++20 标准库（`std::`）模块总览表》，涵盖**所有核心模块和功能分类**，可以作为你深入掌握 C++ 标准库（不仅仅是 STL）的参考手册。
---
# 🧩 C++17/C++20 `std::` 标准库模块总览表
---
## 📦 一、容器模块（Containers）【STL】
| 类型 | 容器名 | 头文件 |
| ------ | ------------------------------------------------------------ | ------------------------------------ |
| 顺序容器 | `vector`, `deque`, `list`, `forward_list`, `array`, `string` | `<vector>`, `<list>`, `<array>` 等 |
| 有序关联容器 | `set`, `multiset`, `map`, `multimap` | `<set>`, `<map>` |
| 无序关联容器 | `unordered_set`, `unordered_map` 等 | `<unordered_set>`, `<unordered_map>` |
| 容器适配器 | `stack`, `queue`, `priority_queue` | `<stack>`, `<queue>` |
---
## ⚙️ 二、算法模块（Algorithms）【STL】
| 功能分类 | 代表算法 | 头文件 |
| ------- | ------------------------------------------------- | ------------- |
| 查找类算法 | `find`, `find_if`, `count` | `<algorithm>` |
| 修改类算法 | `remove`, `replace`, `fill` | `<algorithm>` |
| 排序/排序辅助 | `sort`, `stable_sort`, `nth_element`, `is_sorted` | `<algorithm>` |
| 复制/移动 | `copy`, `move`, `swap` | `<algorithm>` |
| 组合生成 | `next_permutation`, `prev_permutation` | `<algorithm>` |
| 数值算法 | `accumulate`, `inner_product`, `partial_sum` | `<numeric>` |
---
## 🔁 三、迭代器模块（Iterators）【STL】
| 功能 | 关键类型或函数 | 头文件 |
| --------- | --------------------------------------------- | ------------ |
| 迭代器标签 | `input_iterator_tag` 等 | `<iterator>` |
| 插入适配器 | `back_inserter`, `inserter`, `front_inserter` | `<iterator>` |
| 工具函数 | `begin`, `end`, `advance`, `distance` | `<iterator>` |
| C++20 范围库 | `ranges::begin`, `ranges::view` | `<ranges>` |
---
## 🧠 四、函数对象与 Lambda（Function Objects & Lambdas）
| 类型/功能 | 名称 | 头文件 |
| ---------- | ------------------------------------------- | -------------- |
| 算术比较逻辑 | `std::plus`, `greater`, `logical_not` 等 | `<functional>` |
| 函数适配器 | `std::function`, `std::bind`, `std::not_fn` | `<functional>` |
| 成员绑定器 | `std::mem_fn`, `std::ref`, `cref` | `<functional>` |
| Lambda 表达式 | `[=](){}`，可捕获任意变量 | 内建语言特性 |
---
## 🧰 五、实用工具组件（Utility Components）
| 类型 | 名称 | 头文件 |
| ------ | ------------------------------------------- | ---------------------- |
| 元组和对 | `std::pair`, `std::tuple` | `<utility>`, `<tuple>` |
| 可选值 | `std::optional` (C++17) | `<optional>` |
| 任意类型 | `std::any` (C++17) | `<any>` |
| 多态变体类型 | `std::variant` (C++17) | `<variant>` |
| 初始化列表 | `std::initializer_list` | `<initializer_list>` |
| 类型推导工具 | `std::declval`, `std::move`, `std::forward` | `<utility>` |
---
## 🧮 六、数值和数学模块（Math & Numeric）
| 功能 | 名称或函数 | 头文件 |
| --------- | ------------------------------------------ | ----------- |
| 数学函数 | `abs`, `pow`, `sqrt`, `sin`, `exp`, `fmod` | `<cmath>` |
| 复杂数 | `std::complex` | `<complex>` |
| 数值算法 | `accumulate`, `inner_product` | `<numeric>` |
| 随机数生成器 | `mt19937`, `uniform_int_distribution` 等 | `<random>` |
| 比例类型 | `std::ratio` | `<ratio>` |
| 比较（C++20） | `std::partial_ordering`, `strong_ordering` | `<compare>` |
---
## 🕓 七、时间与日期（Time & Date）
| 功能 | 名称 | 头文件 |
| ----------- | ----------------------------- | ---------- |
| 时间度量 | `std::chrono::duration` | `<chrono>` |
| 时钟 | `std::chrono::system_clock` | `<chrono>` |
| 时间点 | `std::chrono::time_point` | `<chrono>` |
| C++20 日期格式化 | `std::chrono::year_month_day` | `<chrono>` |
---
## 🧵 八、线程与并发（Threading & Concurrency）
| 功能 | 名称 | 头文件 |
| ----- | --------------------------------- | ---------------------- |
| 线程 | `std::thread` | `<thread>` |
| 锁 | `std::mutex`, `std::unique_lock` | `<mutex>` |
| 条件变量 | `std::condition_variable` | `<condition_variable>` |
| 原子操作 | `std::atomic` | `<atomic>` |
| 异步任务 | `std::future`, `std::async` | `<future>` |
| 屏障 | `std::barrier` (C++20) | `<barrier>` |
| 信号量 | `std::counting_semaphore` (C++20) | `<semaphore>` |
| 任务调度器 | `std::jthread` (C++20) | `<thread>` |
---
## 📚 九、输入输出流（IOStreams）
| 功能 | 名称 | 头文件 |
| ----- | ------------------------------------ | ------------ |
| 标准流 | `std::cin`, `std::cout`, `std::cerr` | `<iostream>` |
| 文件流 | `std::ifstream`, `std::ofstream` | `<fstream>` |
| 字符串流 | `std::stringstream`, `ostringstream` | `<sstream>` |
| 格式化输出 | `std::setw`, `std::setprecision` | `<iomanip>` |
---
## 🧬 十、类型与模板支持（Type Support & Traits）
| 功能 | 名称 | 头文件 |
| -------------- | ------------------------------------------------------------ | --------------- |
| 类型特征 | `std::is_same`, `is_integral`, ... | `<type_traits>` |
| 类型转换 | `std::static_cast`, `dynamic_cast` | 内建语言特性 |
| 类型工具 | `std::remove_reference`, `enable_if`, `conditional`, `decay` | `<type_traits>` |
| 模板工具 | `std::integral_constant`, `true_type`, `false_type` | `<type_traits>` |
| C++20 concepts | `std::same_as`, `std::integral` | `<concepts>` |
---
## 🧪 十一、诊断与调试（Diagnostics）
| 功能 | 名称 | 头文件 |
| ---- | -------------------------------------- | ---------------- |
| 异常处理 | `std::exception`, `throw`, `try` | `<exception>` |
| 断言 | `assert()` | `<cassert>` |
| 错误代码 | `std::error_code`, `std::system_error` | `<system_error>` |
| 类型信息 | `typeid`, `type_info` | `<typeinfo>` |
---
## 🧱 十二、内存与资源管理
| 功能 | 名称 | 头文件 |
| ---- | ---------------------------------------------- | ---------- |
| 智能指针 | `std::unique_ptr`, `shared_ptr`, `weak_ptr` | `<memory>` |
| 分配器 | `std::allocator`, 自定义分配器 | `<memory>` |
| 内存操作 | `std::addressof`, `std::align`, `std::launder` | `<memory>` |
| 对象管理 | `std::construct_at`, `destroy_at`（C++20） | `<memory>` |
---
## 🗂️ 十三、标准支持组件
| 功能 | 名称 | 头文件 |
| ---------------- | ------------- | ----------- |
| 宏定义 | `__cplusplus` | - |
| `std::size_t` | `<cstddef>` | `<cstddef>` |
| `std::nullptr_t` | `<cstddef>` | `<cstddef>` |
---
## 📘 附录：全部头文件参考索引（常见）
```
<algorithm> 排序、查找、修改序列等算法
<array> 定长数组容器
<bitset> 位数组容器
<chrono> 时间与时钟
<cmath> 数学函数
<complex> 复数
<deque>, <list>, <vector> 动态容器
<exception>, <stdexcept> 异常类
<functional> 函数对象、bind
<iomanip> IO格式化
<iostream> 输入输出流
<iterator> 迭代器工具
<map>, <set>, <unordered_map>, <unordered_set> 关联容器
<memory> 智能指针、分配器
<mutex>, <thread>, <condition_variable> 线程并发
<numeric> 数值算法
<optional>, <variant>, <any> 可选/类型容器
<random> 随机数
<ratio> 比例
<regex> 正则表达式
<string>, <string_view> 字符串处理
<type_traits>, <concepts> 类型支持
<tuple>, <utility> 元组、pair、move、forward
```
---
## 🧭 你接下来的学习建议路线（建议阶段性掌握）
1. **基础入门**：容器 + 算法 + IO 流
2. **实用 STL**：pair、tuple、function、lambda
3. **现代工具**：optional、variant、any、智能指针
4. **并发开发**：thread、mutex、future
5. **泛型编程**：type\_traits、template、concepts
6. **大型项目支持**：chrono、random、filesystem、allocator
---
## 📎 如果你需要
我可以为这份内容：
* 整理为 **PDF 文档**
* 制作为 **Markdown 笔记**
* 绘制成 **思维导图**
* 制作成 **C++ 标准库查阅表格**
你想要哪种版本？也可以选择多个，我可以立刻生成并提供下载。