vault backup: 2026-05-13 11:52:39
This commit is contained in:
@@ -0,0 +1,429 @@
|
||||
---
|
||||
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 "sort"
|
||||
|
||||
nums := []int{3, 1, 4, 1, 5, 9, 2}
|
||||
strs := []string{"banana", "apple", "cherry"}
|
||||
|
||||
// 升序排列
|
||||
sort.Ints(nums) // [1, 1, 2, 3, 4, 5, 9]
|
||||
sort.Strings(strs) // ["apple", "banana", "cherry"]
|
||||
sort.IntsAreSorted(nums) // true（仅检查，不修改）
|
||||
|
||||
// 对已有切片排序（原地修改）
|
||||
sort.Slice(nums, func(i, j int) bool {
|
||||
return nums[i] < nums[j] // 升序
|
||||
})
|
||||
|
||||
// 降序排列
|
||||
sort.Sort(sort.Reverse(sort.IntSlice(nums)))
|
||||
```
|
||||
|
||||
### 自定义排序
|
||||
|
||||
```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`：内联实现，使用插排+堆排混合策略，均摊 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) // "你好世界"
|
||||
|
||||
// ⚠️ 注意：[]rune 转 string 时不能对每个 rune 单独做 string()，必须整体转换
|
||||
// string([]rune{65, 66}) ✅ → "AB"
|
||||
// string(byte('A')) ❌ 编译错误，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`，刷题环境通常已支持
|
||||
Reference in New Issue
Block a user