几何为欢的云站

Blog推送Github仓库常用命令

Sat, 25 Apr 2026 00:00:00 GMT

Blog推送Github仓库常用命令#

0.构建/dist#

Terminal window

1
pnpm build

1.在/dist新建仓库+commit#

Terminal window

1
git init
2
git add .
3
git commit -m "xxx"

2.链接远程仓库+push#

Terminal window

1
#如果原本已经链接过远程仓库，要先清除绑定
2
#git remote remove origin
3
git remote add origin git@github.com:{your_git_name}/{your_repo_name}.git
4
#这里使用ssh，因为国内网络环境，http容易被rst阻断
5
git push -f origin master
6
#我用的是master分支，看你用的github pages选择的发布分支名替换

Mermaid 图表测试

Fri, 20 Mar 2026 00:00:00 GMT

Mermaid 图表测试#

本文测试博客中的 Mermaid 图表渲染功能。

流程图示例#

graph TD A[开始] --> B{是否登录?} B -->|是| C[进入主页] B -->|否| D[跳转到登录页] C --> E[显示用户信息] D --> F[输入用户名密码] F --> G[验证身份] G --> H[验证成功?] H -->|是| C H -->|否| I[显示错误信息] I --> D

序列图示例#

sequenceDiagram participant 用户 participant 网站 participant API participant 数据库用户->>网站: 访问页面网站->>API: 请求数据 API->>数据库: 查询数据库-->>API: 返回结果 API-->>网站: JSON响应网站-->>用户: 渲染页面

饼图示例#

pie title 编程语言使用比例 "JavaScript" : 40 "Python" : 25 "Java" : 20 "其他" : 15

甘特图示例#

gantt title 项目开发计划 dateFormat YYYY-MM-DD section 设计需求分析 :done, des1, 2026-03-01, 7d 原型设计 :active, des2, 2026-03-08, 5d 界面设计 : des3, after des2, 5d section 开发前端开发 : dev1, after des3, 10d 后端开发 : dev2, after des3, 12d section 测试单元测试 : test1, after dev1, 5d 集成测试 : test2, after dev2, 7d

类图示例#

classDiagram class Animal { +String name +int age +eat() +sleep() } class Dog { +bark() } class Cat { +meow() } Animal <|-- Dog Animal <|-- Cat

状态图示例#

stateDiagram-v2 [*] --> 待处理待处理 --> 进行中: 开始处理进行中 --> 已完成: 完成任务进行中 --> 待处理: 取消已完成 --> [*]: 结束

测试完成！

attention的一些关系图

Tue, 10 Mar 2026 00:00:00 GMT

编码成字节，解码成字符。

graph TD subgraph "Post-Norm（原始Transformer）" A1[输入x] --> B1[多头注意力] B1 --> C1[Dropout] A1 --> D1[残差连接 +] C1 --> D1 D1 --> E1[LayerNorm] E1 --> F1[FFN前馈网络] F1 --> G1[Dropout] E1 --> H1[残差连接 +] G1 --> H1 H1 --> I1[LayerNorm] I1 --> J1[输出] end subgraph "Pre-Norm（现代变体）" A2[输入x] --> B2[LayerNorm] B2 --> C2[多头注意力] C2 --> D2[Dropout] A2 --> E2[残差连接 +] D2 --> E2 E2 --> F2[LayerNorm] F2 --> G2[FFN前馈网络] G2 --> H2[Dropout] E2 --> I2[残差连接 +] H2 --> I2 I2 --> J2[输出] end

rust使用速查

Tue, 10 Mar 2026 00:00:00 GMT

哈哈，恭喜！🎉 Rust 确实比 C++ 友好多了，特别是包管理和工具链方面。让我给你一些 Rust 的实用技巧，让你更爽：

1. Rust 常用命令速查#

Terminal window展开收起

1
# 1. 项目管理
2
cargo new my_project          # 创建新项目
3
cargo init                    # 在当前目录初始化
4
cargo build                   # 编译
5
cargo run                     # 编译并运行
6
cargo check                   # 快速检查（不生成二进制）
7
cargo test                    # 运行测试
8
cargo bench                   # 运行基准测试
9

10
# 2. 依赖管理
11
cargo add package_name        # 添加依赖（需要 cargo-edit）
12
cargo update                  # 更新依赖
13
cargo tree                    # 查看依赖树
14
cargo audit                   # 安全检查
15

16
# 3. 代码质量
17
cargo fmt                     # 格式化代码
18
cargo clippy                  # 代码检查（类似 ESLint）
19
cargo doc --open              # 生成并打开文档

展开收起

2. 安装实用工具#

Terminal window

1
# 安装 cargo-edit（方便添加依赖）
2
cargo install cargo-edit
3

4
# 安装 cargo-watch（文件变化时自动重新编译）
5
cargo install cargo-watch
6

7
# 安装 cargo-make（类似 Makefile）
8
cargo install cargo-make
9

10
# 安装 cargo-generate（从模板生成项目）
11
cargo install cargo-generate
12

13
# 安装 cargo-udeps（查找未使用的依赖）
14
cargo install cargo-udeps

3. VS Code 配置#

安装这些扩展：

rust-lang.rust-analyzer（必装）
bungcip.better-toml（TOML 语法高亮）
serayuzgur.crates（依赖管理）
vadimcn.vscode-lldb（调试器）

.vscode/settings.json：

1
{
2
    "rust-analyzer.check.command": "clippy",
3
    "rust-analyzer.checkOnSave": true,
4
    "rust-analyzer.cargo.allFeatures": true,
5
    "editor.formatOnSave": true,
6
    "[rust]": {
7
        "editor.defaultFormatter": "rust-lang.rust-analyzer"
8
    }
9
}

4. 常用依赖推荐#

1
# Cargo.toml 常用依赖
2
[dependencies]
3
# 命令行工具
4
clap = { version = "4.0", features = ["derive"] }  # 命令行解析
5
indicatif = "0.17.0"  # 进度条
6
colored = "2.0.0"     # 彩色输出
7
anyhow = "1.0.0"      # 错误处理
8
thiserror = "1.0.0"   # 自定义错误
9

10
# 数据处理
11
serde = { version = "1.0", features = ["derive"] }
12
serde_json = "1.0"
13
serde_yaml = "0.9"
14
csv = "1.2"
15
reqwest = { version = "0.11", features = ["json"] }
16
tokio = { version = "1.0", features = ["full"] }
17

18
# 实用工具
19
chrono = "0.4.0"      # 日期时间
20
regex = "1.0"         # 正则表达式
21
rand = "0.8.0"        # 随机数
22
rayon = "1.0"         # 并行计算

展开收起

5. 快速开发模板#

Terminal window

1
# 使用模板创建项目
2
cargo generate --git https://github.com/rust-cli/cli-template.git --name my-cli
3

4
# 或者创建自己的模板
5
cargo new --lib my-lib-template

6. 性能优化技巧#

1
// 1. 使用 release 模式编译
2
cargo build --release
3

4
// 2. 使用 #[inline] 标记小函数
5
#[inline]
6
fn add(a: i32, b: i32) -> i32 {
7
    a + b
8
}
9

10
// 3. 避免不必要的克隆
11
fn process_string(s: &str) { /* ... */ }  // 借用而不是拥有
12

13
// 4. 使用迭代器而不是循环
14
let sum: i32 = vec![1, 2, 3].iter().sum();
15

16
// 5. 使用 Cow（写时复制）
17
use std::borrow::Cow;
18
fn process(input: &str) -> Cow<str> {
19
    if input.contains("bad") {
20
        Cow::Owned(input.replace("bad", "good"))
21
    } else {
22
        Cow::Borrowed(input)
23
    }
24
}

展开收起

7. 调试技巧#

1
// 1. 使用 dbg! 宏
2
let x = 5;
3
let y = dbg!(x * 2) + 1;  // 打印中间值
4

5
// 2. 使用 println! 格式化
6
println!("x = {x}, y = {y}");  // Rust 1.58+ 支持
7

8
// 3. 使用 tracing 库进行结构化日志
9
#[tokio::main]
10
async fn main() {
11
    tracing_subscriber::fmt::init();
12

13
    tracing::info!("Starting application");
14
    tracing::debug!("Debug info: {:?}", some_data);
15
    tracing::error!("Something went wrong");
16
}

展开收起

8. 实用脚本#

创建 dev.ps1：

Terminal window展开收起

1
# Rust 开发助手
2
param(
3
    [string]$Command = "help"
4
)
5

6
switch ($Command) {
7
    "run" {
8
        cargo run
9
    }
10
    "watch" {
11
        cargo watch -x run
12
    }
13
    "test" {
14
        cargo test -- --nocapture
15
    }
16
    "bench" {
17
        cargo bench
18
    }
19
    "clean" {
20
        cargo clean
21
        Remove-Item -Recurse -Force target -ErrorAction SilentlyContinue
22
    }
23
    "deps" {
24
        cargo tree
25
    }
26
    "audit" {
27
        cargo audit
28
    }
29
    "update" {
30
        cargo update
31
        rustup update
32
    }
33
    default {
34
        Write-Host "可用命令:" -ForegroundColor Cyan
35
        Write-Host "  .\dev.ps1 run     - 运行项目" -ForegroundColor Green
36
        Write-Host "  .\dev.ps1 watch   - 监视并自动运行" -ForegroundColor Green
37
        Write-Host "  .\dev.ps1 test    - 运行测试" -ForegroundColor Green
38
        Write-Host "  .\dev.ps1 bench   - 运行基准测试" -ForegroundColor Green
39
        Write-Host "  .\dev.ps1 clean   - 清理构建" -ForegroundColor Green
40
        Write-Host "  .\dev.ps1 deps    - 查看依赖树" -ForegroundColor Green
41
        Write-Host "  .\dev.ps1 audit   - 安全检查" -ForegroundColor Green
42
        Write-Host "  .\dev.ps1 update  - 更新所有" -ForegroundColor Green
43
    }
44
}

展开收起

9. 学习资源#

1
## 在线学习
2
- [Rust 官方教程](https://doc.rust-lang.org/book/)
3
- [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
4
- [Rustlings](https://github.com/rust-lang/rustlings) - 小练习
5
- [Exercism Rust Track](https://exercism.org/tracks/rust)
6

7
## 实用工具
8
- [crates.io](https://crates.io/) - Rust 包仓库
9
- [docs.rs](https://docs.rs/) - 文档自动生成
10
- [play.rust-lang.org](https://play.rust-lang.org/) - 在线运行
11

12
## 社区
13
- [Rust 中文社区](https://rustcc.cn/)
14
- [r/rust](https://www.reddit.com/r/rust/)
15
- [Rust Discord](https://discord.gg/rust-lang)

展开收起

10. 快速开始项目#

Terminal window

1
# 创建 CLI 工具
2
cargo new my-cli --bin
3
cd my-cli
4

5
# 添加依赖
6
cargo add clap --features derive
7
cargo add anyhow
8
cargo add colored
9

10
# 运行
11
cargo run -- --name World --count 3

Rust 的编译器和工具链确实比 C++ 友好太多了！享受编码吧！🚀

创建批处理文件用于管理rust的linker

Terminal window展开收起

1
@echo off
2
echo 选择MinGW版本：
3
echo 1. Scoop版本 (C:\Users\user\scoop\apps\mingw-winlibs\current\bin)
4
echo 2. CLion版本 (D:\JetBrains\CLion 2025.1.4\bin\mingw\bin)
5
echo 3. OpenCV版本 (E:\opencv\mingw-build\install\x64\mingw\bin)
6
set /p choice="请输入选择 (1-3): "
7

8
if "%choice%"=="1" (
9
    set PATH=C:\Users\user\scoop\apps\mingw-winlibs\current\bin;%PATH%
10
    echo 已切换到Scoop MinGW
11
) else if "%choice%"=="2" (
12
    set PATH=D:\JetBrains\CLion 2025.1.4\bin\mingw\bin;%PATH%
13
    echo 已切换到CLion MinGW
14
) else if "%choice%"=="3" (
15
    set PATH=E:\opencv\mingw-build\install\x64\mingw\bin;%PATH%
16
    echo 已切换到OpenCV MinGW
17
) else (
18
    echo 无效选择
19
)

展开收起

使用Scoop的MinGW-gcc的powershell：

Terminal window展开收起

1
# 创建 Rust 配置文件
2
$rustConfig = @"
3
# 使用 Scoop 的 MinGW
4
[target.x86_64-pc-windows-gnu]
5
linker = "C:\\Users\\user\\scoop\\apps\\mingw-winlibs\\current\\bin\\gcc.exe"
6
ar = "C:\\Users\\user\\scoop\\apps\\mingw-winlibs\\current\\bin\\ar.exe"
7

8
# 设置默认目标
9
[build]
10
target = "x86_64-pc-windows-gnu"
11
"@
12

13
$rustConfig | Out-File -Encoding UTF8 "$env:USERPROFILE\.cargo\config.toml"
14

15
Write-Host "✅ Rust 配置已更新" -ForegroundColor Green

展开收起

京都旅行（高考后）

Fri, 06 Mar 2026 00:00:00 GMT

本次旅行是笔者在2025年6月实行，鉴于当下国际局势及人身安全，请读者朋友避免该旅行目的地……

其实没有想象中有意思，只有一点点环境差异，氛围区别，笔者准备等到大学结束再去看过的动漫地点巡礼。

笔者拍照技术不好，随便记录一下，别细究好不好看，主要没啥好写的，拿图凑数，主要忘事比较多，想记一记，以后自己再看难免有感想。( • ̀ω•́ )✧

第一天，从笔者家乡飞到关西国际机场，夜里落地，笔者第一次坐飞机，耳鸣有点难受，尤其是落地前半小时遇到暴雨云，空中盘旋了一圈，上下颠簸，差点以为小命要交代在飞机上了……落地后取了行李，坐大巴到酒店时一路上劫后庆幸感充满脑子……(ㄒoㄒ)

第二天早上起床，到隔壁711买了点吃的，鱿鱼丝之类的，还蛮好吃的，然后在酒店边上看看风景。

这个大桥还蛮震撼的，笔者还没去过港珠澳，所以不知道港珠澳大桥实地什么样子，等有钱了就去看。（这次算父母赞助，大学生依旧平+穷开局）T^T

IMG_20250615_063812

鹅卵石中间冒出的小植物，小小的也很可爱，话说这些石头从哪里运来的……┐(・o・)┌

IMG_20250615_064016

IMG_20250615_064042

IMG_20250615_075921

高架上看见了好多海边的化工厂，不知道干嘛的。在B站刷到过国内的镇海炼化，超级壮观，好想去看看。Σ(ﾟдﾟlll)

IMG_20250615_081823

IMG_20250615_082003

IMG_20250615_083506

跑到奈良的春日大社看鹿了，感觉这些鹿还蛮干净的，没啥怪味，就是感觉看见鹿的拜头和下跪有些……诡异和惊悚（个人感觉不具参考意义，不要攻击我）

IMG_20250615_104139

IMG_20250615_104823(1)

这个渠道的水流好评，周围是长期形成的苔藓和蕨类，真的很自然

IMG_20250615_110407

IMG_20250615_112338

这个奈良的公园里面的枫树长得好高大，感觉好漂亮，翠绿，清爽，细密，叶子在风里晃悠，在阴天的光下有些迷离感，有没有懂的（笑

IMG_20250615_112746

IMG_20250615_112749

这些类似于神龛的玩意白天有些肃穆，夜里感觉会把人吓个半死，万一中间冒个鬼火……难绷，自求多福

IMG_20250615_112757

jp大概属于海洋性气候，这边的树长得好大（笔者没选修地理，不记得气候特色树种分类了）盘根错节，落叶巨多

IMG_20250615_113521

IMG_20250615_120251

IMG_20250615_130210

IMG_20250615_130747

IMG_20250615_130858

这张图好像是在艺妓一番街拍的，天气不好，设备也普通，明显欠曝，

IMG_20250615_132112

贴一张笔者在街上祇园辻利吃抹茶冰淇淋的照片，笔者不好看喵，纯纯码农装扮，其实想当赛码娘来着，可惜没有Turing真传的基因……只能线上单推xnn了……对性取向还不明确喵……可爱xnn如果缺对象请联系我喵(〃’▽’〃)

IMG_20250615_133549

跑到金阁寺玩了，听说是聪明的一修里主角原型曾在的地方，虽然一修现实里后期也是私生活很差了（没看过这个动漫，导游讲的）

IMG_20250615_150634

路上遇到大型陵园了，害怕……我们这里的好像没这么挤，他们土地太小了。

IMG_20250615_161908

透过围栏看，好神奇

IMG_20250615_165904

IMG_20250615_172916

IMG_20250615_173345

IMG_20250615_173412

这个照片好像苏北的乡村，自建房+丰收的土地，东亚的乡村风格出奇一致。

好想住回自建房，笔者老家拆迁了，边上建了地铁……

没拆的时候嫌弃房子旧，拆了后悔住进了鸽子笼，还没田种，没鸡喂，难受，精神上有些玉玉了。

IMG_20250615_174346

IMG_20250615_174600

IMG_20250615_175438

IMG_20250615_180528

IMG_20250615_180534

IMG_20250615_183919

IMG_20250615_190609

到酒店住下后，出去觅食，发现一家Google Map上评分4.0+的好店（谷歌地图评分整体不是特别高，对比美团分的评分，发现国内点评分数还是虚高了点）

IMG_20250615_192814

IMG_20250615_195203

IMG_20250615_195205

吃完饭搞了点喝的，面的猪骨头汤好喝，但是有些咸。

IMG_20250615_203957

果蔬汁就这个最好喝，加番茄的口味真的咽不下去。

IMG_20250615_204010

早餐

IMG_20250616_070842

老妈拖着小箱子，我拖着大箱子( ･´ω`･ )

IMG_20250616_075757

IMG_20250616_075813

IMG_20250616_075822

IMG_20250616_080337

IMG_20250616_081443

上了富士山看看，发现上面白的是雪，下面黑的是火山岩石

IMG_20250616_141955

IMG_20250616_142131

IMG_20250616_142335

IMG_20250616_142418

IMG_20250616_143139

IMG_20250616_144337

IMG_20250616_144553

IMG_20250616_144718

IMG_20250616_145011

到了富士山脚下的大石公园，有个湖，还有各种花和房子，风景特别好，等笔者有钱了一定要来度假。

还有卖薰衣草冰淇淋的，没舍得吃，有点贵。

IMG_20250616_162757

IMG_20250616_163023

IMG_20250616_163031

IMG_20250616_163038

IMG_20250616_163058

IMG_20250616_163107

IMG_20250616_163114

IMG_20250616_163204

IMG_20250616_163721

IMG_20250616_163724

IMG_20250616_163728

IMG_20250616_163756

IMG_20250616_163942

IMG_20250616_163947

IMG_20250616_163951

IMG_20250616_164007

IMG_20250616_164016

IMG_20250616_164233

IMG_20250616_164435

IMG_20250616_164443

IMG_20250616_164519

IMG_20250616_164539

IMG_20250616_164555

IMG_20250616_164817

IMG_20250616_165009

IMG_20250616_165117

IMG_20250616_165200

IMG_20250616_165213

IMG_20250616_165311

IMG_20250616_165314

IMG_20250616_165324

IMG_20250616_165444

IMG_20250616_165616

IMG_20250616_170303

IMG_20250616_170333

IMG_20250616_170628

python和java中hashset和hashmap的区别

Fri, 24 Oct 2025 00:00:00 GMT

在 Java、Python 等语言中，HashMap（哈希映射）和 HashSet（哈希集合）都是基于哈希表实现的数据结构，但它们的核心功能和语法特性有本质区别，主要体现在存储内容、用途和操作方式上。以下从常见语言（以 Java 为例，兼顾 Python）对比两者的语法区别：

一、核心区别：存储的内容不同#

HashMap：存储键值对（key-value），通过键（key）快速查找值（value），键不可重复（重复会覆盖旧值），值可重复。
HashSet：存储单一元素（value），元素不可重复，本质上是通过 HashMap 实现的（将元素作为 HashMap 的 key，value 为固定空对象）。

二、Java 中的语法区别#

特性	HashMap	HashSet
初始化	`HashMap<K, V> map = new HashMap<>();`	`HashSet<E> set = new HashSet<>();`
添加元素	`put(key, value)`：添加键值对，返回被覆盖的旧值（无则返回 null）	`add(element)`：添加元素，成功返回 true（重复返回 false）
删除元素	`remove(key)`：通过键删除键值对，返回被删除的值	`remove(element)`：直接删除元素，返回是否成功
查找元素	`containsKey(key)`：判断键是否存在 `get(key)`：通过键获取值（无则返回 null）	`contains(element)`：判断元素是否存在无 `get` 方法（无需获取，只需判断存在性）
遍历方式	遍历键：`keySet()` 遍历值：`values()` 遍历键值对：`entrySet()`	遍历元素：`iterator()` 或增强 for 循环
核心用途	存储映射关系（如字典、缓存）	去重、判断元素是否存在（如集合运算）
示例	`map.put("name", "Alice");` `String name = map.get("name"); // "Alice"`	`set.add("Alice");` `boolean has = set.contains("Alice"); // true`

三、Python 中的对应结构（dict 与 set）#

Python 中没有 HashMap 和 HashSet 的类名，但功能对应：

dict（字典） 对应 HashMap，存储键值对。
set（集合） 对应 HashSet，存储单一元素。

语法区别类似：

特性	dict（对应 HashMap）	set（对应 HashSet）
初始化	`d = {"name": "Alice"}` 或 `dict()`	`s = {"Alice"}` 或 `set()`
添加元素	`d[key] = value` 或 `d.update({key: value})`	`s.add(element)` 或 `s.update(iterable)`
删除元素	`del d[key]` 或 `d.pop(key)`	`s.remove(element)`（不存在报错）或 `s.discard(element)`（不报错）
查找元素	`key in d`（判断键是否存在） `d.get(key)`（获取值）	`element in s`（判断元素是否存在）
遍历方式	遍历键：`for key in d` 遍历值：`for val in d.values()` 遍历键值对：`for k, v in d.items()`	遍历元素：`for elem in s`

四、总结：核心语法差异点#

存储内容：HashMap 存键值对，HashSet 存单一元素。
核心方法：
- HashMap 用 put(key, value) 添加，get(key) 获取值。
- HashSet 用 add(element) 添加，contains(element) 判断存在。
用途：HashMap 用于映射关系，HashSet 用于去重和集合操作。

本质上，HashSet 可以看作是 HashMap 的”简化版”（只存键，不存值），两者都依赖哈希表实现 O(1) 级别的增删查效率。

C++STL之numeric库用法

Sat, 18 Oct 2025 00:00:00 GMT

<numeric> 头文件提供数值运算相关函数，以下是核心函数及用法：

1. accumulate - 累加/累积#

1
vector<int> v = {1,2,3,4,5};
2
int sum = accumulate(v.begin(), v.end(), 0);                    // 15
3
int product = accumulate(v.begin(), v.end(), 1, multiplies<>()); // 120

2. inner_product - 内积计算#

1
vector<int> a = {1,2,3}, b = {4,5,6};
2
int dot = inner_product(a.begin(), a.end(), b.begin(), 0);      // 32
3
int sum_abs_diff = inner_product(a.begin(), a.end(), b.begin(), 0, plus<>(),
4
                                [](int x, int y){return abs(x-y);}); // 9

3. adjacent_difference - 相邻差值#

1
vector<int> nums = {2,4,6,8};
2
vector<int> diff(4);
3
adjacent_difference(nums.begin(), nums.end(), diff.begin());    // [2,2,2,2]
4
adjacent_difference(nums.begin(), nums.end(), diff.begin(), multiplies<>()); // [2,8,24,48]

4. partial_sum - 前缀和#

1
vector<int> nums = {1,2,3,4};
2
vector<int> prefix(4);
3
partial_sum(nums.begin(), nums.end(), prefix.begin());         // [1,3,6,10]
4
partial_sum(nums.begin(), nums.end(), prefix.begin(), multiplies<>()); // [1,2,6,24]

5. gcd - 最大公约数 (C++17)#

1
int a = 12, b = 18;
2
int result = gcd(a, b);  // 6
3
int result2 = gcd(48, 60); // 12

6. lcm - 最小公倍数 (C++17)#

1
int a = 12, b = 18;
2
int result = lcm(a, b);  // 36
3
int result2 = lcm(4, 6); // 12

7. midpoint - 安全中点 (C++17)#

1
int x = 10, y = 20;
2
int mid = midpoint(x, y);  // 15
3
double dmid = midpoint(1.5, 3.5); // 2.5

综合示例#

1
vector<int> data = {1,3,5};
2
int total = accumulate(data.begin(), data.end(), 0);           // 9
3
vector<int> pre(3), diff(3);
4
partial_sum(data.begin(), data.end(), pre.begin());            // [1,4,9]
5
adjacent_difference(data.begin(), data.end(), diff.begin());   // [1,2,2]

sort-template

Fri, 10 Oct 2025 00:00:00 GMT

给我这些排序的特点、原理、cpp可实现代码，方便我学习以及亲自手敲代码#

选择排序（多次”打擂台”）
冒泡排序
插入排序
计数排序
基数排序
快速排序
归并排序（分治）
堆排序
桶排序
希尔排序（并非常见）
锦标赛排序（并非常见）
Tim排序（并非常见）

以下是各类排序算法的特点、原理及C++实现代码，按常用程度和逻辑复杂度排序，方便学习和手敲练习：

1. 选择排序（Selection Sort）#

特点#

原理简单，不稳定排序（如[2,2,1]会交换第一个2和1，破坏稳定性）。
时间复杂度：O(n²)，空间复杂度：O(1)。
适合小规模数据，交换次数少（最多n-1次）。

原理#

每次从待排序区间选择最小（或最大）元素，放到区间起始位置，重复直到排序完成。

C++实现#

1
#include <vector>
2
using namespace std;
3

4
void selectionSort(vector<int>& arr) {
5
    int n = arr.size();
6
    for (int i = 0; i < n - 1; ++i) {
7
        int minIdx = i;  // 记录最小值索引
8
        for (int j = i + 1; j < n; ++j) {
9
            if (arr[j] < arr[minIdx]) {
10
                minIdx = j;
11
            }
12
        }
13
        swap(arr[i], arr[minIdx]);  // 交换到当前位置
14
    }
15
}

展开收起

2. 冒泡排序（Bubble Sort）#

特点#

原理直观，稳定排序（相等元素不交换）。
时间复杂度：O(n²)，空间复杂度：O(1)。
适合几乎有序的数据（可优化提前终止）。

原理#

重复遍历数组，每次比较相邻元素，顺序错误则交换，直到没有元素交换（排序完成）。

C++实现#

1
#include <vector>
2
using namespace std;
3

4
void bubbleSort(vector<int>& arr) {
5
    int n = arr.size();
6
    bool swapped;  // 优化：判断是否已有序
7
    for (int i = 0; i < n - 1; ++i) {
8
        swapped = false;
9
        for (int j = 0; j < n - i - 1; ++j) {  // 尾部已排序，无需再比较
10
            if (arr[j] > arr[j + 1]) {
11
                swap(arr[j], arr[j + 1]);
12
                swapped = true;
13
            }
14
        }
15
        if (!swapped) break;  // 无交换，提前终止
16
    }
17
}

展开收起

3. 插入排序（Insertion Sort）#

特点#

稳定排序，适合小规模或部分有序数据。
时间复杂度：O(n²)，空间复杂度：O(1)。
实际应用中比冒泡排序高效（移动操作比交换少）。

原理#

将数组分为「已排序」和「未排序」两部分，每次从后者取一个元素，插入前者的合适位置。

C++实现#

1
#include <vector>
2
using namespace std;
3

4
void insertionSort(vector<int>& arr) {
5
    int n = arr.size();
6
    for (int i = 1; i < n; ++i) {
7
        int key = arr[i];
8
        int j = i - 1;
9
        while (j >= 0 && arr[j] > key) {
10
            arr[j + 1] = arr[j];
11
            --j;
12
        }
13
        arr[j + 1] = key;
14
    }
15
}

展开收起

（其余排序算法代码略，请参考完整文章）

py-os-walk

Thu, 09 Oct 2025 00:00:00 GMT

os.walk() 是Python中用于遍历目录树的强大函数，它可以递归地访问指定目录下的所有子目录和文件。

基本语法#

1
import os
2

3
for root, dirs, files in os.walk(top, topdown=True, onerror=None, followlinks=False):
4
    # 处理逻辑

参数说明：

top：要遍历的根目录路径
topdown：如果为True，先遍历顶级目录再子目录；如果为False，先遍历子目录
onerror：错误处理函数
followlinks：是否跟随符号链接

返回值说明#

每次迭代返回一个三元组：

基础用法示例#

1. 基本遍历#

1
import os
2

3
# 遍历当前目录
4
for root, dirs, files in os.walk('.'):
5
    print(f"当前目录: {root}")
6
    print(f"子目录: {dirs}")
7
    print(f"文件: {files}")
8
    print("-" * 50)

2. 获取所有文件路径#

1
import os
2

3
def get_all_files(directory):
4
    """获取目录下所有文件的完整路径"""
5
    all_files = []
6
    for root, dirs, files in os.walk(directory):
7
        for file in files:
8
            full_path = os.path.join(root, file)
9
            all_files.append(full_path)
10
    return all_files
11

12
# 使用示例
13
files = get_all_files('.')
14
for file in files:
15
    print(file)

展开收起

3. 查找特定类型文件#

1
import os
2

3
def find_files_by_extension(directory, extensions):
4
    """查找指定扩展名的文件"""
5
    found_files = []
6
    for root, dirs, files in os.walk(directory):
7
        for file in files:
8
            if any(file.endswith(ext) for ext in extensions):
9
                full_path = os.path.join(root, file)
10
                found_files.append(full_path)
11
    return found_files
12

13
# 查找所有Python和文本文件
14
python_and_txt_files = find_files_by_extension('.', ['.py', '.txt', '.md'])
15
for file in python_and_txt_files:
16
    print(file)

展开收起

高级用法示例#

4. 控制遍历顺序（topdown参数）#

1
import os
2

3
print("自上而下遍历 (默认):")
4
for root, dirs, files in os.walk('.', topdown=True):
5
    print(f"访问: {root}")
6

7
print("\n自下而上遍历:")
8
for root, dirs, files in os.walk('.', topdown=False):
9
    print(f"访问: {root}")

5. 过滤目录#

1
import os
2

3
def walk_with_filter(directory, exclude_dirs=None):
4
    """遍历时排除特定目录"""
5
    if exclude_dirs is None:
6
        exclude_dirs = ['.git', '__pycache__', 'node_modules']
7

8
    for root, dirs, files in os.walk(directory):
9
        # 从dirs中移除要排除的目录（防止os.walk进入这些目录）
10
        dirs[:] = [d for d in dirs if d not in exclude_dirs]
11

12
        print(f"当前目录: {root}")
13
        print(f"过滤后子目录: {dirs}")
14
        print(f"文件: {files}")
15
        print("-" * 50)
16

17
# 使用示例
18
walk_with_filter('.')

展开收起

6. 错误处理#

1
import os
2

3
def handle_walk_error(error):
4
    """错误处理函数"""
5
    print(f"遍历错误: {error}")
6

7
# 带有错误处理的遍历
8
try:
9
    for root, dirs, files in os.walk('/some/path', onerror=handle_walk_error):
10
        print(f"处理: {root}")
11
except Exception as e:
12
    print(f"严重错误: {e}")

7. 计算目录大小#

1
import os
2

3
def get_directory_size(directory):
4
    """计算目录总大小"""
5
    total_size = 0
6
    for root, dirs, files in os.walk(directory):
7
        for file in files:
8
            file_path = os.path.join(root, file)
9
            try:
10
                total_size += os.path.getsize(file_path)
11
            except OSError:
12
                # 忽略无法访问的文件
13
                pass
14
    return total_size
15

16
# 使用示例
17
size = get_directory_size('.')
18
print(f"目录总大小: {size} bytes ({size / 1024 / 1024:.2f} MB)")

展开收起

8. 查找重复文件#

1
import os
2
import hashlib
3

4
def get_file_hash(filepath):
5
    """计算文件的MD5哈希值"""
6
    hash_md5 = hashlib.md5()
7
    with open(filepath, "rb") as f:
8
        for chunk in iter(lambda: f.read(4096), b""):
9
            hash_md5.update(chunk)
10
    return hash_md5.hexdigest()
11

12
def find_duplicate_files(directory):
13
    """查找重复文件"""
14
    file_hashes = {}
15
    duplicates = []
16

17
    for root, dirs, files in os.walk(directory):
18
        for file in files:
19
            file_path = os.path.join(root, file)
20
            try:
21
                file_hash = get_file_hash(file_path)
22
                if file_hash in file_hashes:
23
                    duplicates.append((file_path, file_hashes[file_hash]))
24
                else:
25
                    file_hashes[file_hash] = file_path
26
            except (OSError, IOError):
27
                continue
28

29
    return duplicates
30

31
# 使用示例
32
duplicates = find_duplicate_files('.')
33
for dup in duplicates:
34
    print(f"重复文件: {dup[0]} 和 {dup[1]}")

展开收起

9. 文件统计#

1
import os
2

3
def analyze_directory(directory):
4
    """分析目录结构"""
5
    stats = {
6
        'total_dirs': 0,
7
        'total_files': 0,
8
        'file_types': {},
9
        'largest_file': ('', 0)
10
    }
11

12
    for root, dirs, files in os.walk(directory):
13
        stats['total_dirs'] += len(dirs)
14
        stats['total_files'] += len(files)
15

16
        for file in files:
17
            # 统计文件类型
18
            _, ext = os.path.splitext(file)
19
            file_type = ext.lower() if ext else '无扩展名'
20
            stats['file_types'][file_type] = stats['file_types'].get(file_type, 0) + 1
21

22
            # 查找最大文件
23
            file_path = os.path.join(root, file)
24
            try:
25
                file_size = os.path.getsize(file_path)
26
                if file_size > stats['largest_file'][1]:
27
                    stats['largest_file'] = (file_path, file_size)
28
            except OSError:
29
                pass
30

31
    return stats
32

33
# 使用示例
34
stats = analyze_directory('.')
35
print(f"总目录数: {stats['total_dirs']}")
36
print(f"总文件数: {stats['total_files']}")
37
print("文件类型分布:")
38
for file_type, count in stats['file_types'].items():
39
    print(f"  {file_type}: {count}")
40
print(f"最大文件: {stats['largest_file'][0]} ({stats['largest_file'][1]} bytes)")

展开收起

10. 批量重命名文件#

1
import os
2

3
def rename_files_in_directory(directory, old_ext, new_ext):
4
    """批量重命名指定扩展名的文件"""
5
    renamed_count = 0
6

7
    for root, dirs, files in os.walk(directory):
8
        for file in files:
9
            if file.endswith(old_ext):
10
                old_path = os.path.join(root, file)
11
                new_file = file.replace(old_ext, new_ext)
12
                new_path = os.path.join(root, new_file)
13

14
                try:
15
                    os.rename(old_path, new_path)
16
                    print(f"重命名: {old_path} -> {new_path}")
17
                    renamed_count += 1
18
                except OSError as e:
19
                    print(f"重命名失败 {old_path}: {e}")
20

21
    return renamed_count
22

23
# 使用示例：将所有的.txt文件改为.md
24
# renamed = rename_files_in_directory('.', '.txt', '.md')
25
# print(f"重命名了 {renamed} 个文件")

展开收起

注意事项#

性能考虑：对于非常大的目录树，os.walk() 可能会消耗较多内存
权限问题：可能会遇到权限不足无法访问的目录
符号链接：默认不跟随符号链接，设置 followlinks=True 可以改变此行为
实时修改：在遍历过程中修改 dirs 列表可以控制遍历行为

os.walk() 是文件系统操作中非常有用的工具，特别适合需要递归处理目录结构的场景。

C++与Python的tuple对比

Wed, 08 Oct 2025 00:00:00 GMT

1. Python中的Tuple#

基本用法#

1
# 创建tuple
2
t1 = (1, 2, 3)
3
t2 = tuple([4, 5, 6])
4
t3 = 1, 2, 3  # 括号可以省略
5
single_element = (1,)  # 单元素tuple需要逗号
6

7
# 访问元素
8
print(t1[0])     # 1
9
print(t1[-1])    # 3 (倒数第一个)
10

11
# 解包
12
a, b, c = t1
13
print(a, b, c)  # 1 2 3
14

15
# 部分解包
16
a, *rest = t1
17
print(a, rest)  # 1 [2, 3]
18

19
# 常用操作
20
print(len(t1))           # 3
21
print(2 in t1)           # True
22
print(t1 + (4, 5))       # (1, 2, 3, 4, 5)
23
print(t1 * 2)            # (1, 2, 3, 1, 2, 3)

展开收起

高级特性#

1
# 命名tuple
2
from collections import namedtuple
3
Point = namedtuple('Point', ['x', 'y'])
4
p = Point(10, 20)
5
print(p.x, p.y)  # 10 20
6

7
# 作为字典键（因为不可变）
8
dict_with_tuple = {(1, 2): "value"}
9
print(dict_with_tuple[(1, 2)])  # "value"
10

11
# 函数返回多个值
12
def get_coordinates():
13
    return 10, 20, 30
14

15
x, y, z = get_coordinates()

展开收起

2. C++中的Tuple#

基本用法#

1
#include <tuple>
2
#include <iostream>
3
#include <string>
4

5
using namespace std;
6

7
int main() {
8
    // 创建tuple
9
    tuple<int, string, double> t1(1, "hello", 3.14);
10
    auto t2 = make_tuple(2, "world", 2.71);
11

12
    // 访问元素
13
    cout << get<0>(t1) << endl;  // 1
14
    cout << get<1>(t1) << endl;  // "hello"
15

16
    // 解包（C++17）
17
    auto [a, b, c] = t1;
18
    cout << a << " " << b << " " << c << endl;
19

20
    return 0;
21
}

展开收起

高级用法#

1
#include <tuple>
2
#include <iostream>
3

4
// 传统解包方式（C++11/14）
5
void traditional_unpack() {
6
    auto t = make_tuple(1, "hello", 3.14);
7

8
    int a;
9
    string b;
10
    double c;
11

12
    tie(a, b, c) = t;  // 传统解包
13
    cout << a << " " << b << " " << c << endl;
14
}
15

16
// 比较操作
17
void compare_tuples() {
18
    tuple<int, string> t1(1, "apple");
19
    tuple<int, string> t2(2, "banana");
20

21
    if (t1 < t2) {
22
        cout << "t1 < t2" << endl;
23
    }
24
}
25

26
// 连接tuple
27
template<typename... T1, typename... T2>
28
auto tuple_cat_example(tuple<T1...> t1, tuple<T2...> t2) {
29
    return tuple_cat(t1, t2);
30
}

展开收起

3. 主要区别对比#

特性	Python Tuple	C++ Tuple
可变性	不可变	不可变
类型要求	可包含不同类型	可包含不同类型
访问方式	`t[index]`	`get<index>(t)`
解包	直接解包 `a, b = t`	`auto [a, b] = t` (C++17)
动态性	运行时确定长度	编译时确定长度和类型
作为字典键	可以（因为不可变）	可以（需要hash支持）
性能	相对较慢	编译时优化，零成本抽象

4. 实用示例对比#

Python示例#

1
# 交换变量
2
a, b = 1, 2
3
a, b = b, a  # 使用tuple交换
4

5
# 函数多返回值
6
def get_user_info():
7
    return "John", 25, "Developer"
8

9
name, age, job = get_user_info()
10

11
# 遍历多个tuple
12
points = [(1, 2), (3, 4), (5, 6)]
13
for x, y in points:
14
    print(f"Point: ({x}, {y})")

C++示例#

1
#include <tuple>
2
#include <vector>
3
#include <iostream>
4

5
// 多返回值
6
tuple<string, int, string> getUserInfo() {
7
    return make_tuple("John", 25, "Developer");
8
}
9

10
// 结构化绑定遍历
11
void iteratePoints() {
12
    vector<tuple<int, int>> points = {
13
        make_tuple(1, 2),
14
        make_tuple(3, 4),
15
        make_tuple(5, 6)
16
    };
17

18
    for (const auto& [x, y] : points) {
19
        cout << "Point: (" << x << ", " << y << ")" << endl;
20
    }
21
}
22

23
int main() {
24
    // 多返回值使用
25
    auto [name, age, job] = getUserInfo();
26
    cout << name << " is a " << age << " year old " << job << endl;
27

28
    iteratePoints();
29
    return 0;
30
}

展开收起

总结#

Python tuple：更灵活，语法简洁，广泛用于多返回值、不可变序列等场景
C++ tuple：类型安全，性能更好，但语法相对复杂，需要编译时确定类型

两者都是处理异构数据集合的重要工具，但在设计哲学和使用方式上有明显差异。Python更注重开发效率，C++更注重运行效率和类型安全。

iterator用法

Wed, 08 Oct 2025 00:00:00 GMT

什么是 Iterator（迭代器）？#

核心思想： 迭代器是一种设计模式，它提供了一种方法，能够顺序访问一个聚合对象（如列表、容器）中的各个元素，而又不需要暴露该对象的内部表示。

你可以把迭代器想象成一个智能指针，它知道如何在容器中”遍历”或”移动”，并访问每个元素。

关键点：

抽象了遍历过程：无论底层数据结构是数组、链表、树还是哈希表，使用迭代器的代码看起来都差不多。
统一了访问接口：为不同的容器提供了一个统一的遍历访问接口。
保护了数据：用户通过迭代器访问元素，而不需要知道容器是如何存储这些元素的。

C++ 中的迭代器#

在 C++ 中，迭代器是 STL（标准模板库）的核心组成部分之一。它被设计得像指针一样，支持 *（解引用）、++（自增）等操作。

C++ 迭代器的类别：

输入迭代器：只读，且只能向前移动。
输出迭代器：只写，且只能向前移动。
前向迭代器：可读写，只能向前移动。
双向迭代器：可读写，能向前和向后移动（如 list, map, set 的迭代器）。
随机访问迭代器：功能最强，可读写，能跳跃式移动（如 vector, deque 的迭代器），支持 +, -, [] 等操作。

C++ 示例：

1
#include <iostream>
2
#include <vector>
3
#include <list>
4

5
int main() {
6
    // 1. 使用 vector (随机访问迭代器)
7
    std::vector<int> vec = {1, 2, 3, 4, 5};
8

9
    std::cout << "Vector iteration: ";
10
    // 使用 begin() 和 end() 获取迭代器
11
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
12
        std::cout << *it << " "; // 通过 * 解引用访问元素
13
    }
14
    std::cout << std::endl;
15

16
    // 2. 使用 list (双向迭代器)
17
    std::list<std::string> lst = {"Hello", "World", "C++"};
18

19
    std::cout << "List iteration: ";
20
    // 使用 auto 简化迭代器类型声明
21
    for (auto it = lst.begin(); it != lst.end(); ++it) {
22
        std::cout << *it << " ";
23
    }
24
    std::cout << std::endl;
25

26
    // 3. 反向迭代
27
    std::cout << "Reverse iteration: ";
28
    for (auto it = vec.rbegin(); it != vec.rend(); ++it) { // rbegin(), rend() 返回反向迭代器
29
        std::cout << *it << " ";
30
    }
31
    std::cout << std::endl;
32

33
    // 4. 基于范围的 for 循环 (底层也是使用迭代器)
34
    std::cout << "Range-based for loop: ";
35
    for (const auto& value : vec) {
36
        std::cout << value << " ";
37
    }
38
    std::cout << std::endl;
39

40
    return 0;
41
}

展开收起

输出：

1
Vector iteration: 1 2 3 4 5
2
List iteration: Hello World C++
3
Reverse iteration: 5 4 3 2 1
4
Range-based for loop: 1 2 3 4 5

Python 中的迭代器#

Python 的迭代器协议更加简洁和统一，是 Python for 循环的基础。

Python 迭代器协议： 一个对象是迭代器，当且仅当它实现了以下两个方法：

__iter__(): 返回迭代器对象本身（self）。
__next__(): 返回容器的下一个元素。如果没有更多元素，则抛出 StopIteration 异常。

任何实现了 __iter__() 方法的对象都是 可迭代对象（Iterable）。当调用 iter() 函数时，它会调用对象的 __iter__() 方法来获取一个迭代器。

Python 示例：

1
# 1. 使用内置可迭代对象 (list, tuple, string, dict)
2
my_list = [1, 2, 3, 4, 5]
3

4
print("List iteration: ", end="")
5
for item in my_list:
6
    print(item, end=" ")
7
print()
8

9
# 2. 手动模拟 for 循环的过程
10
print("Manual iteration: ", end="")
11
iterator_obj = iter(my_list) # 获取迭代器
12
while True:
13
    try:
14
        item = next(iterator_obj)
15
        print(item, end=" ")
16
    except StopIteration:
17
        break
18
print()
19

20
# 3. 字典迭代
21
my_dict = {'a': 1, 'b': 2, 'c': 3}
22
print("Dict iteration (keys): ", end="")
23
for key in my_dict:
24
    print(key, end=" ")
25
print()
26

27
print("Dict iteration (items): ", end="")
28
for key, value in my_dict.items():
29
    print(f"{key}:{value}", end=" ")
30
print()
31

32
# 4. 创建一个自定义迭代器
33
class CountDown:
34
    def __init__(self, start):
35
        self.current = start
36

37
    def __iter__(self):
38
        return self
39

40
    def __next__(self):
41
        if self.current <= 0:
42
            raise StopIteration
43
        else:
44
            num = self.current
45
            self.current -= 1
46
            return num
47

48
print("Custom iterator: ", end="")
49
counter = CountDown(3)
50
for num in counter:
51
    print(num, end=" ")

展开收起

输出：

1
List iteration: 1 2 3 4 5
2
Manual iteration: 1 2 3 4 5
3
Dict iteration (keys): a b c
4
Dict iteration (items): a:1 b:2 c:3
5
Custom iterator: 3 2 1

C++ 与 Python 迭代器的对比总结#

特性	C++	Python
核心概念	类似智能指针，是 STL 算法的基石。	遵循迭代器协议（`__iter__`, `__next__`），是 `for` 循环的基础。
获取方式	通过容器的 `begin()`, `end()` 等方法。	通过内置函数 `iter()` 作用于可迭代对象。
遍历方式	使用 `++it` 移动，`*it` 解引用。	使用 `next()` 函数或 `__next__()` 方法。
结束判断	将迭代器与 `end()` 返回的尾后迭代器比较。	捕获 `StopIteration` 异常。
类别	分为多种（输入、输出、前向、双向、随机访问），功能不同。	协议统一，但行为可能不同（如序列是顺序，字典是键的顺序）。
语法糖	基于范围的 for 循环 (`for (auto x : container)`)。	`for` 循环 (`for x in iterable:`)。

总结#

Iterator 是一个强大的抽象工具，它让你可以用相同或相似的代码来处理各种不同的数据结构。
在 C++ 中，迭代器是 STL 六大组件之一，与算法和容器紧密配合，是编写通用、高效 C++ 代码的关键。
在 Python 中，迭代器协议是语言的核心特性之一，它使得 for 循环如此简洁和强大，并且可以轻松创建自定义的可迭代对象。

理解迭代器对于深入掌握这两种语言的编程范式至关重要。

github push commands

Fri, 01 Apr 2022 00:00:00 GMT

github push代码#

1.新建本地仓库#

Terminal window

1
git init

2.将所有文件加入暂存区索引#

Terminal window

1
git add .

3.与远程仓库建立连接#

Terminal window

1
git remote add origin git@github.com:账户名/仓库名

4.将暂存区索引提交到本地仓库#

Terminal window

1
git commit -m "提交说明"

5.将本地仓库推送至远程仓库#

Terminal window

1
git push -u origin 远程分支名称（最近使用master）

valaxy常用指令

Fri, 01 Apr 2022 00:00:00 GMT

1.预览：pnpm dev

2.构建：pnpm run build

3.github上传：

Terminal window

1
git commit -m "提交说明"
2

3
git push -u origin 远程分支名称（最近使用master）