471 lines
14 KiB
Markdown
471 lines
14 KiB
Markdown
---
|
||
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 个数，最后两层用双指针收尾，每层都加上同样的去重逻辑即可。
|