--- tags: ["Go", "哈希表"] create time: 2026-05-13 15:00 --- # 2026-05-13 ## Go 中的 Hash Map 与 Hash Set > [!question] 💡 思考 > Go 标准库中没有像 Python 或 Java 那样的原生 `set` 类型——它是如何实现集合的？ ### Hash Map：`map[K]V` Go 的哈希映射通过内建类型 `map[K]V` 实现，K 必须支持 `==` 比较运算符，V 可以是任意类型。 #### 声明与初始化 ```go // 方式一：make 创建空 map（最常用） mp := make(map[int]int) // 方式二：字面量直接初始化 ages := map[string]int{ "Alice": 30, "Bob": 25, } // 方式三：nil map（不可写入！读可以） var nilMap map[string]int // nilMap == nil → true nilMap["key"] = 1 // ❌ panic: assignment to entry in nil map ``` > [!warning] ⚠️ nil vs 空 map > - `var m map[K]V` 声明后值为 `nil`，此时**只能读不能写**，写入会 panic > - `make(map[K]V)` 创建的是真正的空 map，可读可写 > - 如果不确定，可以用 `len(m) == 0 && m == nil` 同时判断是否为 nil #### 基本操作 ```go mp := make(map[int]string) // 插入 / 更新 mp[1] = "one" // 查询：不存在的 key 返回零值 val := mp[999] // val == ""（int→string 的零值） // 安全查询：双返回值判断 key 是否存在 val, ok := mp[1] // val="one", ok=true _, exists := mp[999] // exists=false // 删除 delete(mp, 1) delete(mp, 999) // 删除不存在的 key 不会 panic // 遍历 for k, v := range mp { fmt.Println(k, v) } // 元素个数 n := len(mp) ``` > [!info] 🐹 零值陷阱 > 查找不存在的 key 时，Go 返回该值的**零值**（零值因 V 的类型而异），所以无法直接用 `mp[key] == 0` 判断 key 不存在——如果 key 对应的值恰好就是 0，结果会有歧义。务必使用 `(val, ok)` 双返回值模式。 | 操作 | 代码 | 说明 | |------|------|------| | 插入/更新 | `mp[key] = value` | key 存在则覆盖 | | 安全读取 | `v, ok := mp[key]` | ok=true 表示 key 存在 | | 不安全读取 | `v := mp[key]` | 返回零值，可能误判 | | 删除 | `delete(mp, key)` | 幂等，删不存在的 key 不 panic | | 判空 | `len(mp) == 0` | 但不能区分 nil 和非 nil 空 map | ### Hash Set：用 `map[K]struct{}` 实现 Go 没有内置的 `set`，惯用做法是用 `map[K]struct{}`。`struct{}` 大小为 **0 字节**，比 `bool` 或 `int` 更省内存。 ```go // 方式一：make + struct{} seen := make(map[int]struct{}) seen[42] = struct{}{} delete(seen, 42) // 方式二：map[int]bool（也可用，但 bool 占 1 字节） seenBool := make(map[int]bool) seenBool[42] = true // 查询成员身份（集合的核心操作） if _, exists := seen[42]; exists { fmt.Println("42 in set") } ``` > [!tip] 🔑 为什么选 struct{} 而非 bool？ > > | 类型 | 单个元素开销 | n 个元素的额外开销 | > |------|-------------|-------------------| > | `map[K]struct{}` | 0 bytes | 零 | > | `map[K]bool` | 1 byte | n bytes | > | `map[K]int` | 8 bytes (amd64) | 8n bytes | > > 当集合规模达到百万级时，`struct{}` 能节省显著内存。日常刷题用 `bool` 也无妨，语义更直观。 > [!example] 📝 HashSet 实战模板 > ```go > func containsDuplicate(nums []int) bool { > seen := make(map[int]struct{}) > for _, num := range nums { > if _, exists := seen[num]; exists { > return true > } > seen[num] = struct{}{} > } > return false > } > ``` ## Go 中的字符串与字节切片转换 > [!question] 💡 思考 > Go 的 `string` 是不可变类型，那如何修改其中的字符？这就需要借助 `[]byte`。 ### string → []byte ```go s := "hello" // 方式一：直接转换（创建新的 []byte 副本） b := []byte(s) // b == []byte{'h', 'e', 'l', 'l', 'o'} // ⚠️ 重要：这一步完成了「内存拷贝」 // s 本身不会改变，b 是独立的副本 ``` **底层关系图解：** ```mermaid graph LR A["string s"] -->|"不可变"| B("数据存储在只读区") C["[]byte b = []byte(s)"] -->|"内存拷贝"| D("数据存放在可写的堆/栈上") D --> E["可以修改 b[0] = 'H' ✅"] style B fill:#f9d0d0 style D fill:#d0f0d0 ``` > [!warning] ⚠️ string → []byte 是深拷贝 > - 每次转换都会分配新内存并复制所有字节 > - 高频调用时注意性能开销，LeetCode 刷题通常无需担心 ### []byte → string ```go b := []byte{'h', 'e', 'l', 'l', 'o'} s := string(b) // s == "hello" // 双向转换常用于原地修改字符串： s = "abc" b = []byte(s) b[0] = 'X' // 修改的是 []byte，不影响原 string s = string(b) // s == "Xbc" ``` ### bytes 包常用工具函数 刷题中更常见的是用 `bytes` 包替代手动转换，语义更清晰： ```go import "bytes" s := "hello world" b := []byte(s) // 判断是否包含子串（比循环快） bytes.Contains(b, []byte("world")) // true bytes.HasPrefix(b, []byte("hello")) // true bytes.HasSuffix(b, []byte("world")) // true // 查找子串首次出现的位置 idx := bytes.Index(b, []byte("world")) // idx == 6 // 替换、分割 bytes.ReplaceAll(b, []byte("hello"), []byte("hi")) // []byte("hi world") bytes.Split(b, []byte(" ")) // [][]byte{{'h','e','l','l','o'}, {'w','o','r','l','d'}} ``` > [!tip] 🔑 string vs []byte 选择指南 > > | 场景 | 推荐类型 | 原因 | > |------|---------|------| > | 只读操作 | `string` | 不可变，零额外开销 | > | 需要修改字符 | `[]byte` | 可写副本 | > | Unicode/UTF-8 | `[]rune` | rune 等价于 int32，正确处理多字节字符 | --- ## Go 中的排序 Go 的排序功能集中在 `sort` 包中，支持对整型切片、字符串切片进行快速排序，也可自定义排序逻辑。 ### 内建排序 ```go import ( "cmp" // slices.Sort 需要 "sort" ) nums := []int{3, 1, 4, 1, 5, 9, 2} strs := []string{"banana", "apple", "cherry"} // sort 包内建排序 sort.Ints(nums) // [1, 1, 2, 3, 4, 5, 9] sort.Strings(strs) // ["apple", "banana", "cherry"] sort.IntsAreSorted(nums) // true（仅检查，不修改） // slices.Sort（Go 1.21+）— 基本类型一行搞定 slices.Sort(nums) // [1, 1, 2, 3, 4, 5, 9] slices.Sort(strs) // ["apple", "banana", "cherry"] ``` > [!info] 🔑 slices.Sort vs sort.Slice > > | 维度 | `slices.Sort` | `sort.Slice` | > |------|-------------|-------------| > | 来源 | `cmp/slices`（Go 1.21+） | `sort`（Go 1.0） | > | 类型约束 | `cmp.Ordered`（基本比较类型） | `any`（任意类型） | > | 自定义排序 | ❌ 不支持 | ✅ 传入比较函数 | > | 性能 | 内部高度优化 | 闭包间接调用有开销 | > > **选择原则**：基本类型简单排序 → `slices.Sort`；结构体多字段 / 降序 / 旧版 Go → `sort.Slice`。 ### 自定义排序 #### sort.Slice ```go type Pair struct { Key string Value int } pairs := []Pair{ {"a", 3}, {"b", 1}, {"c", 2}, } // 按 Value 升序排序 sort.Slice(pairs, func(i, j int) bool { return pairs[i].Value < pairs[j].Value }) // 结果: [{"a",3}, {"b",1}, {"c",2}] → [{"b",1}, {"c",2}, {"a",3}] ``` ### 排序稳定性 — sort.SliceStable ```go type Student struct { Name string Score int } students := []Student{ {"Alice", 90}, {"Bob", 85}, {"Charlie", 90}, } // SliceStable 保持相等元素的原始相对顺序 sort.SliceStable(students, func(i, j int) bool { return students[i].Score < students[j].Score }) // Bob(85), Alice(90), Charlie(90) — Alice 仍在 Charlie 前面 ``` > [!tip] 🔑 算法复杂度 > - `sort.Ints` / `sort.Strings` / `slices.Sort`：内联实现，使用插排+堆排混合策略，均摊 O(n log n)，常数极小 > - `sort.Slice`：基于 quicksort，O(n log n)，但自定义比较函数有间接调用开销 > - `sort.Stable`：内层使用稳定排序（如 merge sort），最坏情况仍 O(n log n) > [!info] 🐹 刷题常用排序技巧 > - **计数排序思想**：若元素范围有限（如频率统计），用 map 或数组代替 sort 效率更高 > - **先排序再双指针**：许多哈希题换个思路可以用「排序 + 双指针」解决，降低空间复杂度到 O(1) > - **字符频次**：`b := []byte(s); sort.Slice(b, func(i,j int) bool { return b[i] < b[j] })` 排序后可线性扫描统计字母异位词或重复字符 --- ## 数组 / 切片 → 字符串的转换 ### []byte / []rune → string ```go // []byte → string（最常用） s := string([]byte{'h', 'e', 'l', 'l', 'o'}) // "hello" // []rune → string（Unicode 场景） r := []rune("你好世界") s := string(r) // "你好世界" // ⚠️ byte 和 rune 是不同类型，不能混用： // string(byte('A')) ❌ 编译错误，byte 不是 rune // 处理中文/emoji 时必须用 []rune，而非 []byte ``` ### []string → string（用分隔符拼接） ```go import "strings" fruits := []string{"apple", "banana", "cherry"} // strings.Join — Go 标准库中专门处理这种场景 result := strings.Join(fruits, ", ") // "apple, banana, cherry" result = strings.Join(fruits, "") // "applebananacherry" ``` > [!tip] 🔑 strings.Join 底层实现 > `strings.Join` 内部会先计算总长度，然后一次性分配内存并用 `strings.Builder` 写入——性能与手动循环 + Builder 等效。除非有额外逻辑（如跳过空值），否则直接用 Join 更简洁。 ### fmt.Sprint / strconv 系列 — 数值切片转字符串 ```go import ( "fmt" "strconv" "strings" ) nums := []int{1, 2, 3, 4} // 方法一：Sprintf（最简单，但性能较差） fmt.Sprintf("%v", nums) // "[1 2 3 4]" fmt.Sprintf("%+v", nums) // "[1 2 3 4]"（带字段名，仅结构体有效） // 方法二：手动转换（高效，LeetCode 推荐） func intSliceToString(nums []int) string { strs := make([]string, len(nums)) for i, n := range nums { strs[i] = strconv.Itoa(n) } return "[" + strings.Join(strs, ", ") + "]" } // 输出: "[1, 2, 3, 4]" ``` > [!warning] ⚠️ 各类型零值汇总 > | 类型 | 零值 | > |------|------| > | `string` | `""` | > | `int` | `0` | > | `bool` | `false` | > | `map[K]V` | `nil` | > | `slice` | `nil` | > | `pointer` | `nil` | --- ## Go 中的字符串拼接（StringBuilder） > [!question] 💡 思考 > Java 有 `StringBuilder` 优化大量字符串拼接，Go 中有哪些方式？它们的性能差异有多大？ ### ⚠️ 为什么不能直接 `+=`？ ```go s := "" for i := 0; i < 1000; i++ { s += "a" // ❌ 每次循环都创建新的 string，O(n²) } // 因为 Go 的 string 是不可变的，+= 等于创建新内存拷贝 ``` ### strings.Builder — Go 版的 StringBuilder ✅ ```go import "strings" var sb strings.Builder // 初始化时可预分配容量，避免多次扩容 sb.Grow(100) // 写入各种类型 sb.WriteString("hello") // 写入字符串 sb.WriteByte(' ') // 写入单字节 sb.WriteRune('你好') // 写入 Unicode 字符 fmt.Fprintf(&sb, "%d", 42) // 格式化写入 // 获取最终结果（只读转换，不修改内部缓冲区） result := sb.String() // result == "hello 42" // 重置复用，无需重新分配 sb.Reset() sb.WriteString("new content") ``` **完整实战示例：** ```go func joinStrings(words []string, sep string) string { if len(words) == 0 { return "" } // 预估总长度，一次分配到位 totalLen := 0 for _, w := range words { totalLen += len(w) + len(sep) } var sb strings.Builder sb.Grow(totalLen - len(sep)) // 减去最后一个分隔符 for i, w := range words { if i > 0 { sb.WriteString(sep) } sb.WriteString(w) } return sb.String() } ``` ### 各方案对比 | 方案 | 时间复杂度 | 空间开销 | 推荐场景 | |------|-----------|---------|---------| | `+=` / `+` | O(n²) | 每轮分配新内存 | **禁止**在循环中使用 | | `[]byte` + `string()` | O(n) | 额外 byte 副本 | 需要原地修改字符时 | | `bytes.Buffer` | O(n) | Buffer 结构体开销 | 需要读写双向操作 | | `strings.Builder` | O(n) | 最小化（Grow 可预分配） | **字符串拼接首选** | > [!tip] 🔑 strings.Builder vs bytes.Buffer 怎么选？ > - 纯字符串拼接 → `strings.Builder`，接口更简洁，零额外内存拷贝 > - 需要同时处理字节级和字符串级操作 → `bytes.Buffer` > - Go 1.10+ 才引入了 `strings.Builder`，刷题环境通常已支持 --- ## 🧠 今日收获：排序 + 去重的联动思维 源自 [[双指针/06-三数之和]]，最核心的启发是：**「排序」不只是为算法服务，更是为「去重」铺路。** ### 为什么排序后去重如此优雅？ 排序让**相同的值聚集在一起**。当我们已经遍历过一个值并得到结果后，下一个相同的值必然紧跟其后——只需比较前一个位置就能跳过整个重复段，无需额外空间（如 map 或 set）。 ### 三层去重模式 在"固定一点、双指查找"的问题中，每个决策点都可能产生重复解，需要在**每一层都加去重判断**： | 层级 | 代码 | 时机 | |------|------|------| | **外层 i** | `if i > 0 && nums[i] == nums[i-1]: continue` | 枚举固定点时，前驱已作为固定点完整枚举过 | | **左指针 left** | `left++; while left < right && nums[left] == nums[left-1]: left++` | 找到解后右移，跳过所有与刚走过的 left 相同的值 | | **右指针 right** | `right--; while left < right && nums[right] == nums[right+1]: right--` | 找到解后左移，跳过所有与刚跳过的 right 相同的值 | ### 关键细节 > [!warning] ⚠️ 容易出错的地方 > 1. **先去重再移动指针 → 漏解**。正确顺序：记录答案 → 去重 → 继续搜索。 > 2. **比较对象要搞对**：left 和 `nums[left-1]` 比（刚走过的），right 和 `nums[right+1]` 比（刚跳过的）。 > 3. **i 的范围是 n-2 而非 n**：最后两个位置留给 left 和 right。 > > 这条模式可以推广到四数之和（LeetCode 18）、K 数之和——依次固定 k-2 个数，最后两层用双指针收尾，每层都加上同样的去重逻辑即可。