Update/content with code editing (#62)

* feat(online-compiler): 源码默认可见 + 左右分栏布局

- 桌面左右分栏（源码 | 操作+结果），<912px 自动上下
- 源码进入视口懒加载（IntersectionObserver），减少并发请求
- 编辑源码改为 toggle：再点保存编辑内容并切回只读预览
- 有 ARM 源码时加「源码/ARM 精简源码」tab，看 ARM 汇编自动对照
- 本期纯文本等宽，shiki 语法高亮留作后续

* feat: vol3 writes, refactorizing and todo sync

* feat(online-compiler): 源码区 C++ 语法高亮（shiki）

- 只读源码用 shiki/bundle/web runtime 高亮，复用 github-light/dark 双主题
- 动态 import + 单例懒加载，不污染首屏 bundle（shiki 已随 vitepress 安装，无需加依赖）
- 双主题经 html.dark + --shiki-light/dark 变量自动切换，无需刷新
- 高亮异步：未就绪先纯文本 fallback，就绪后替换为着色 HTML
- 编辑态 textarea 保持纯文本（编辑场景不高亮）

* feat: refactor the old passages

* feat: c++26 formater support and new passages

* feat(vol3): 重构example vol3~7目录和在线源码接入

- 14 篇 OnlineCompilerDemo 配齐(补 map、重写 initializer、新建 8 个)
- vol34567 拆成 vol3/vol4/vol5/vol6/vol7，vol3 重新连续编号 01-14
- 同步更新所有 sourcePath(含 EN)

* feat(i18n): 同步英文翻译:vol3 在线源码接入+目录拆分

- 25 个文件重译(glm-4.6)，vol3 14 篇 EN 齐全含 OnlineCompilerDemo
- EN source-path 同步到 code/examples/vol3-7 新结构
- EN vol3 index 升级到 14 篇逻辑顺序

* chore: 全仓 reading_time 补全 + frontmatter 规范化

- check_quality --fix 补全 reading_time_minutes + frontmatter 字母序规范化
- 修 vol3 deque/map 的 internal_link 缺 .md（4 处 CN+EN）
- EN 翻译同步 25 文件# Please enter the commit message for your changes. Lines starting

Author: Charliechen114514

README.md

@@ -19,7 +19,7 @@
 ---
 
 <!-- COVERAGE_START -->
-![English Coverage](https://img.shields.io/badge/en_coverage-100%25-green.svg) 433/433 docs translated
+![English Coverage](https://img.shields.io/badge/en_coverage-100%25-green.svg) 439/439 docs translated
 <!-- COVERAGE_END -->
 
 ## 这是什么项目

code/examples/vol3/01_container_selection.cpp

@@ -0,0 +1,42 @@
+// Standard: C++20
+// 容器选择：演示「按操作选容器」——按位置存 vs 按键查，呼应选择决策树
+#include <iostream>
+#include <list>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+int main() {
+    std::cout << "== 按位置存：顺序容器，关心在哪插删 ==\n";
+    std::vector<int> v;
+    for (int i = 0; i < 5; ++i) {
+        v.push_back(i); // 尾部摊还 O(1)
+    }
+    std::list<int> lt;
+    for (int i = 0; i < 5; ++i) {
+        lt.push_front(i); // 头部 O(1)
+    }
+    std::cout << "vector 尾插 5 个（尾部摊还 O(1)），list 头插 5 个（头部 O(1)）\n";
+    std::cout << "→ 频繁头尾进出用 deque，主要尾部增长用 vector（务必 reserve）\n";
+
+    std::cout << "\n== 按键查：关联容器，关心按什么查 ==\n";
+    constexpr int N = 100'000;
+    std::map<int, int> om;
+    std::unordered_map<int, int> um;
+    for (int i = 0; i < N; ++i) {
+        om[i] = i;
+        um[i] = i;
+    }
+    std::cout << "map.find(N/2) 命中: " << (om.find(N / 2) != om.end())
+              << "（O(log n) 红黑树，可有序遍历）\n";
+    std::cout << "unordered_map.find(N/2) 命中: " << (um.find(N / 2) != um.end())
+              << "（平均 O(1) 哈希，最快）\n";
+    std::cout << "→ 要有序遍历用 map，只要快查用 unordered（记得 reserve）\n";
+
+    std::cout << "\n== 决策三问（挑容器先问这三件事）==\n";
+    std::cout << "1) 大小编译期已知且不变？→ array\n";
+    std::cout << "2) 按键查找？→ 有序遍历用 map/set，否则 unordered（平均 O(1)）\n";
+    std::cout << "3) 按位置存？→ 头尾用 deque，尾部用 vector，已知位置频繁增删用 list\n";
+    std::cout << "拿不准就 vector：连续、尾部摊还 O(1)、接口最全，覆盖面最广的安全牌\n";
+    return 0;
+}

code/examples/vol34567/01_array.cpp code/examples/vol3/02_array.cppcode/examples/vol34567/01_array.cpp renamed to code/examples/vol3/02_array.cpp

@@ -0,0 +1,53 @@
+// Standard: C++20
+// deque / list / forward_list：vector 之外的三个选择——头插都 O(1)，但内存布局与 splice 各异
+#include <deque>
+#include <forward_list>
+#include <iostream>
+#include <list>
+
+int main() {
+    std::cout << "== 三者头插都 O(1)，但存储布局不同 ==\n";
+    constexpr int N = 100'000;
+
+    std::deque<int> dq;
+    for (int i = 0; i < N; ++i) {
+        dq.push_front(i); // 分段连续，头尾均 O(1)
+    }
+
+    std::list<int> lt;
+    for (int i = 0; i < N; ++i) {
+        lt.push_front(i); // 双向链表节点
+    }
+
+    std::forward_list<int> fl;
+    for (int i = 0; i < N; ++i) {
+        fl.push_front(i); // 单向链表，最省内存（无 prev 指针）
+    }
+    std::cout << "各头插 " << N << " 个，复杂度都是 O(1)\n";
+
+    std::cout << "\n== sizeof：forward_list 最省，deque 有分段控制开销 ==\n";
+    std::cout << "sizeof(deque<int>)        = " << sizeof(dq) << '\n';
+    std::cout << "sizeof(list<int>)         = " << sizeof(lt) << '\n';
+    std::cout << "sizeof(forward_list<int>) = " << sizeof(fl) << '\n';
+
+    std::cout << "\n== list::splice：O(1) 把整串节点搬过来，零拷贝 ==\n";
+    std::list<int> a{1, 2, 3};
+    std::list<int> b{10, 20};
+    auto it = a.begin();
+    ++it;            // 指向元素 2
+    a.splice(it, b); // 把 b 整个接到 a 的 it 之前，搬节点不拷贝
+    std::cout << "splice 后 a = ";
+    for (auto x : a) {
+        std::cout << x << ' ';
+    }
+    std::cout << "\nb 现在 size = " << b.size() << "（节点被搬走，b 空了）\n";
+
+    std::cout << "\n== forward_list 没有 size()：单向链表数元素要 O(n) ==\n";
+    int cnt = 0;
+    for (auto x : fl) {
+        (void)x;
+        ++cnt;
+    }
+    std::cout << "forward_list 手动数 = " << cnt << '\n';
+    return 0;
+}

…xamples/vol34567/15_vector_deep_dive.cpp …de/examples/vol3/03_vector_deep_dive.cppcode/examples/vol34567/15_vector_deep_dive.cpp renamed to code/examples/vol3/03_vector_deep_dive.cpp code/examples/vol34567/15_vector_deep_dive.cpp renamed to code/examples/vol3/03_vector_deep_dive.cpp

@@ -0,0 +1,43 @@
+// Standard: C++20
+// map / set：底层红黑树按键有序、异构查找（transparent 比较器，string_view 直接查）、extract
+// 节点搬家
+#include <iostream>
+#include <map>
+#include <string>
+#include <string_view>
+
+int main() {
+    std::cout << "== map 底层红黑树：按键自动有序 ==\n";
+    std::map<int, std::string> m;
+    m[3] = "three";
+    m[1] = "one";
+    m[2] = "two";
+    std::cout << "插入 3,1,2 后遍历（自动有序）：";
+    for (const auto& [k, v] : m) {
+        std::cout << k << ':' << v << ' ';
+    }
+    std::cout << '\n';
+
+    std::cout << "\n== 异构查找：用 string_view 查 string 的 map，免构造临时 string ==\n";
+    std::map<std::string, int, std::less<>> sm; // std::less<> = 透明比较器
+    sm["apple"] = 1;
+    sm["banana"] = 2;
+    std::string_view key = "banana";
+    auto it = sm.find(key); // string_view 直接查，不构造临时 string
+    if (it != sm.end()) {
+        std::cout << "find(string_view) 命中: " << it->second << '\n';
+    }
+    std::cout << "（用 std::less<> 而非 std::less<std::string>，比较器才支持异构 key）\n";
+
+    std::cout << "\n== extract：把节点从一棵 map 搬到另一棵，零拷贝 ==\n";
+    std::map<int, std::string> a{{1, "one"}, {2, "two"}};
+    std::map<int, std::string> b;
+    auto node = a.extract(1);  // 抽出节点（连带 string，不拷贝）
+    b.insert(std::move(node)); // 接到 b
+    std::cout << "extract(1) 后 a.size = " << a.size() << ", b.size = " << b.size() << '\n';
+    std::cout << "（extract 搬节点不拷贝 string，适合改 key、换分配器、跨 map 转移）\n";
+
+    std::cout << "\n== 复杂度：查找/插入/删除均 O(log n) ==\n";
+    std::cout << "要有序遍历用 map/set；只要平均 O(1) 查找用 unordered 版\n";
+    return 0;
+}

…e/examples/vol34567/16_string_memory.cpp code/examples/vol3/04_string_memory.cppcode/examples/vol34567/16_string_memory.cpp renamed to code/examples/vol3/04_string_memory.cpp code/examples/vol34567/16_string_memory.cpp renamed to code/examples/vol3/04_string_memory.cpp

@@ -0,0 +1,41 @@
+// Standard: C++20
+// unordered_map：哈希桶、rehash 触发的质数桶序列、load_factor、reserve 预撑桶
+#include <iostream>
+#include <unordered_map>
+
+int main() {
+    std::cout << "== rehash 触发质数桶序列（bucket_count 跳变）==\n";
+    std::unordered_map<int, int> m;
+    std::size_t last = m.bucket_count();
+    std::cout << "初始 bucket_count = " << last << '\n';
+    for (int i = 0; i < 200; ++i) {
+        m[i] = i;
+        if (m.bucket_count() != last) {
+            std::cout << "插入 " << i << " 后 rehash: " << last << " -> " << m.bucket_count()
+                      << "（load_factor=" << m.load_factor() << "）\n";
+            last = m.bucket_count();
+        }
+    }
+
+    std::cout << "\n== 桶分布：看元素怎么落桶（链地址法）==\n";
+    std::unordered_map<int, int> small;
+    for (int i = 0; i < 10; ++i) {
+        small[i] = i;
+    }
+    int non_empty = 0;
+    for (std::size_t b = 0; b < small.bucket_count(); ++b) {
+        if (small.bucket_size(b) > 0) {
+            ++non_empty;
+            std::cout << "bucket " << b << " 有 " << small.bucket_size(b) << " 个元素\n";
+        }
+    }
+    std::cout << "共 " << small.bucket_count() << " 个桶，" << non_empty << " 个非空\n";
+    std::cout << "max_load_factor = " << small.max_load_factor()
+              << "（默认 1.0，平均每桶元素数超了就 rehash）\n";
+
+    std::cout << "\n== reserve 预撑桶，避免 hot path 里反复 rehash ==\n";
+    std::unordered_map<int, int> reserved;
+    reserved.reserve(1000); // 内部按 max_load_factor 算出足够的桶
+    std::cout << "reserve(1000) 后 bucket_count = " << reserved.bucket_count() << '\n';
+    return 0;
+}

code/examples/vol3/05_deque_list_forward_list.cpp

@@ -0,0 +1,52 @@
+// Standard: C++20
+// 容器适配器：stack(LIFO) / queue(FIFO) / priority_queue(堆)——priority_queue 默认最大堆，greater
+// 变最小堆
+#include <functional>
+#include <iostream>
+#include <queue>
+#include <stack>
+#include <vector>
+
+int main() {
+    std::cout << "== stack：LIFO，top/push/pop 全在 back 一端 ==\n";
+    std::stack<int> s;
+    for (int x : {1, 2, 3}) {
+        s.push(x);
+    }
+    std::cout << "push 1,2,3 后，top = " << s.top() << "（最后进的先出）\n";
+
+    std::cout << "\n== queue：FIFO，push 在 back、front/pop 在 front ==\n";
+    std::queue<int> q;
+    for (int x : {1, 2, 3}) {
+        q.push(x);
+    }
+    std::cout << "push 1,2,3 后，front = " << q.front() << " back = " << q.back() << '\n';
+
+    std::cout << "\n== priority_queue 默认最大堆（vector + less）==\n";
+    std::priority_queue<int> pq;
+    for (int x : {5, 1, 9, 3, 7}) {
+        pq.push(x);
+    }
+    std::cout << "依次 pop: ";
+    while (!pq.empty()) {
+        std::cout << pq.top() << ' ';
+        pq.pop();
+    }
+    std::cout << '\n';
+
+    std::cout << "\n== 换 greater 变最小堆 ==\n";
+    std::priority_queue<int, std::vector<int>, std::greater<int>> min_pq;
+    for (int x : {5, 1, 9, 3, 7}) {
+        min_pq.push(x);
+    }
+    std::cout << "依次 pop: ";
+    while (!min_pq.empty()) {
+        std::cout << min_pq.top() << ' ';
+        min_pq.pop();
+    }
+    std::cout << '\n';
+
+    std::cout << "\n== 复杂度：top O(1)，push/pop O(log n) ==\n";
+    std::cout << "（push = push_back + push_heap；pop = pop_heap + pop_back；底层就是堆算法）\n";
+    return 0;
+}