277 lines
8.7 KiB
Markdown
277 lines
8.7 KiB
Markdown
---
|
||
tags: ["Go", "算法技巧", "索引", "区间", "避坑"]
|
||
create time: 2026-05-15 15:30
|
||
---
|
||
|
||
# 02-SliceIntervalReference - Go 切片区间与索引操作速查
|
||
|
||
## 核心原则：Go 切片是左闭右开 `[start, end)`
|
||
|
||
这是所有索引操作的根基。理解这一点后，所有 `+1/-1` 问题都可以**推导而非死记**。
|
||
|
||
```go
|
||
s := []int{3, 1, 4, 1, 5, 9, 2, 6}
|
||
// 索引: 0 1 2 3 4 5 6 7
|
||
|
||
s[2:5] // [4, 1, 5] → 包含 start(2)，不包含 end(5)
|
||
// ^-------^
|
||
// [2, 5) ← 左闭右开区间
|
||
```
|
||
|
||
---
|
||
|
||
## 一、三大提取模式
|
||
|
||
> [!tip] 🔑 一句话规则
|
||
>
|
||
> **你手里有 start+length 时用 `s[start : start+len]`；你手里有 start+end 时用 `s[start : end]`。**
|
||
|
||
| 场景 | 表达式 | 示例 |
|
||
|------|--------|------|
|
||
| **已知起始位置和长度** | `s[start : start+len]` | `s[2 : 2+3] = s[2:5]` |
|
||
| **已知起止索引（均含）** | `s[left : right+1]` | 窗口 `[left, right]` → `s[left:right+1]` |
|
||
| **已知起止索引（右不含）** | `s[start : end]` | `s[0 : len(s)]` = 整个切片 |
|
||
| **从末尾倒数 N 个** | `s[len(s)-N :]` | `s[len(s)-3:]` = 最后 3 个 |
|
||
|
||
### 逐步验证
|
||
|
||
```go
|
||
// 假设 left=2, right=4（表示索引 2~4，共 3 个元素）
|
||
left := 2
|
||
right := 4
|
||
s[left : right+1] // s[2:5] → [4, 1, 5] ✅
|
||
// ↑ ↑ ↑
|
||
// left 保留 right+1 结果恰好是索引 2,3,4 三个元素
|
||
// （因为右端点不可取）
|
||
```
|
||
|
||
> [!question] 💡 为什么是 `right+1` 而不是 `right`？
|
||
>
|
||
> 思考题：如果直接写 `s[left:right]`，实际截取的是索引 `left` 到 `right-1`——**少了最后一个元素**。
|
||
>
|
||
> **答案**：因为 Go 切片是左闭右开 `[start, end)`，当算法中的区间定义为闭区间 `[left, right]`（左右都包含）时，切片的第二个参数必须加 1 才能覆盖到 `right` 这个位置。
|
||
|
||
---
|
||
|
||
## 二、循环边界规律
|
||
|
||
### 基本模式
|
||
|
||
```go
|
||
// 遍历索引 0 ~ n-1（共 n 个元素）
|
||
for i := 0; i < n; i++ { // ✅ 标准：严格小于
|
||
_ = s[i]
|
||
}
|
||
|
||
// 遍历闭区间 [left, right]（共 right-left+1 个元素）
|
||
for i := left; i <= right; i++ { // ✅ 闭合区间用 <=
|
||
_ = s[i]
|
||
}
|
||
|
||
// 遍历半开区间 [left, right)（共 right-left 个元素）
|
||
for i := left; i < right; i++ { // ✅ 半开区间用 <
|
||
_ = s[i]
|
||
}
|
||
```
|
||
|
||
### 滑动窗口中常见的两种循环写法
|
||
|
||
```go
|
||
// 写法 A：右边界 for-range（最常用）
|
||
for right, char := range s { // right ∈ [0, len(s))
|
||
// ...
|
||
}
|
||
|
||
// 写法 B：双指针手动控制
|
||
for left := 0; left < len(s); {
|
||
// ...
|
||
left++ // 注意：只有 ++ 没有 i--
|
||
}
|
||
|
||
// 写法 C：内外层收缩
|
||
for right := 0; right < len(s); right++ {
|
||
// expand
|
||
for formed == required {
|
||
// shrink
|
||
left++ // left 永远单调递增，不会越界
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 三、常见场景速查表 ⭐
|
||
|
||
### 场景 1：子串/子数组
|
||
|
||
```go
|
||
// ── 提取窗口内容 ─────────────────────
|
||
bestStart := 2
|
||
bestLen := 3
|
||
result := s[bestStart : bestStart+bestLen]
|
||
// ^^^^^^^^^^ ^^^^^^^^^^^
|
||
// 起始位置 结束位置=start+len
|
||
|
||
// ── 提取固定区间 [left, right] ─────
|
||
left, right := 2, 4
|
||
window := s[left : right+1] // +1 是因为右端要包含 right
|
||
// ^^^
|
||
```
|
||
|
||
### 场景 2：二分查找
|
||
|
||
```go
|
||
func search(nums []int, target int) int {
|
||
left, right := 0, len(nums)-1 // 闭区间 [0, n-1]
|
||
|
||
for left <= right { // 闭区间 → <=
|
||
mid := left + (right-left)/2
|
||
if nums[mid] == target {
|
||
return mid
|
||
} else if nums[mid] < target {
|
||
left = mid + 1 // 排除 mid，+1
|
||
} else {
|
||
right = mid - 1 // 排除 mid，-1
|
||
}
|
||
}
|
||
return -1
|
||
}
|
||
```
|
||
|
||
> [!warning] ⚠️ 二分查找的关键对应关系
|
||
>
|
||
> | 区间定义 | while 条件 | 左移 | 右移 |
|
||
> |---------|-----------|------|------|
|
||
> | `[left, right]` 闭区间 | `left <= right` | `left = mid + 1` | `right = mid - 1` |
|
||
> | `[left, right)` 半开区间 | `left < right` | `left = mid + 1` | `right = mid` |
|
||
|
||
### 场景 3：前缀和
|
||
|
||
```go
|
||
pref := make([]int, n+1) // 比原数组多一位！
|
||
for i := 0; i < n; i++ {
|
||
pref[i+1] = pref[i] + arr[i]
|
||
}
|
||
|
||
// 区间 [l, r] 的和 = pref[r+1] - pref[l]
|
||
sum := pref[r+1] - pref[l]
|
||
// ^^^ ← +1：前缀和的索引比原数组大一位
|
||
```
|
||
|
||
> [!tip] 🔑 记忆口诀：前缀和多一位，求和用 r+1 减 l。
|
||
|
||
### 场景 4：差分数组
|
||
|
||
```go
|
||
diff := make([]int, n+1) // 同样需要多一位
|
||
|
||
// 区间 [l, r] 统一加 v
|
||
diff[l] += v
|
||
diff[r+1] -= v // +1：r 之后才恢复
|
||
|
||
// 还原原数组
|
||
for i := 1; i < n; i++ {
|
||
diff[i] += diff[i-1]
|
||
}
|
||
```
|
||
|
||
### 场景 5：矩阵坐标
|
||
|
||
```go
|
||
// 行 [r1, r2], 列 [c1, c2]（均闭区间）
|
||
for r := r1; r <= r2; r++ {
|
||
for c := c1; c <= c2; c++ {
|
||
_ = matrix[r][c] // 访问合法
|
||
}
|
||
}
|
||
|
||
// 提取子矩阵
|
||
sub := make([][]int, r2-r1+1)
|
||
for i := 0; i < len(sub); i++ {
|
||
sub[i] = matrix[r1+i][c1 : c2+1] // 列方向也要 +1
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 四、常见陷阱对照表
|
||
|
||
| 错误写法 | 正确写法 | 问题说明 |
|
||
|---------|---------|---------|
|
||
| `s[start:end-1]` | `s[start:end]` | 少了最后一个元素（本来就不该取 end） |
|
||
| `s[left:right-1]` | `s[left:right+1]` | 闭区间 `[left,right]` 需转半开 `[left, right+1)` |
|
||
| `for i<=n; i++` | `for i<n; i++` | `s[n]` 越界（索引最大为 n-1） |
|
||
| `mid = (left+right)/2` | `mid = left+(right-left)/2` | `left+right` 可能溢出（虽然 Go 不溢出但这是习惯） |
|
||
| `if mid == target` 后用 `break` | 直接 `return mid` | break 只跳出内层循环，漏了后续逻辑 |
|
||
| `diff[r] -= v` | `diff[r+1] -= v` | 差分应在区间结束后恢复，不是结束时 |
|
||
| `prefix[r]-prefix[l-1]` | `prefix[r+1]-prefix[l]` | 如果用 1-indexed 前缀和，公式不同 |
|
||
|
||
---
|
||
|
||
## 五、思维模型：从区间语义推导表达式
|
||
|
||
遇到不确定的 `+1/-1` 时，按以下流程推导：
|
||
|
||
```mermaid
|
||
flowchart TD
|
||
A["确定区间语义"] --> B{"区间定义方式?"}
|
||
B -->|"闭区间 [l, r]"| C["两端都包含"]
|
||
B -->|"半开区间 [l, r)"| D["左包含，右不包含"]
|
||
C --> E["切片需要覆盖 r<br/>→ 第二个参数 = r+1"]
|
||
D --> F["第二个参数本身就是 r<br/>→ 直接用 s[l:r]"]
|
||
E --> G["for 循环用 l <= r"]
|
||
F --> H["for 循环用 l < r"]
|
||
G --> I["写出代码<br/>用小规模样例验证"]
|
||
H --> I
|
||
I --> J["✅ 确认无误"]
|
||
```
|
||
|
||
### 实例演练
|
||
|
||
```
|
||
题目：找到最长无重复子串的长度
|
||
状态：left=2, right=5（当前窗口覆盖索引 2~5）
|
||
|
||
问：如何提取这段子串？
|
||
|
||
推导步骤：
|
||
1. 区间定义：[left, right] = [2, 5] → 闭区间，包含两端
|
||
2. Go 切片语法：[start, end) → 第二个参数不能取到
|
||
3. 所以 end = right + 1 = 6
|
||
4. 结果：s[2:6] → 覆盖索引 2,3,4,5 ✅
|
||
|
||
验证：s[2:6] 长度 = 6-2 = 4，而 [2,5] 元素个数 = 5-2+1 = 4 ✓
|
||
```
|
||
|
||
---
|
||
|
||
## 六、速查卡片 🃏
|
||
|
||
> [!success] ✅ 一页搞定
|
||
|
||
```
|
||
┌──────────────────────────────────────────────────┐
|
||
│ Go 切片 +1/-1 速查卡 │
|
||
├──────────────────────────────────────────────────┤
|
||
│ │
|
||
│ 已知 start + len → s[start : start+len] │
|
||
│ 已知 [left, right] → s[left : right+1] │
|
||
│ 已知 [start, end) → s[start : end] │
|
||
│ │
|
||
│ 闭区间 for → i <= r │
|
||
│ 半开区间 for → i < r │
|
||
│ │
|
||
│ 二分 [l,r] → while l<=r, l=mid+1, r=mid-1 │
|
||
│ 二分 [l,r) → while l<r, l=mid+1, r=mid │
|
||
│ │
|
||
│ 前缀和 [l,r] → pref[r+1] - pref[l] │
|
||
│ 差分数 [l,r] → diff[l]+=v, diff[r+1]-=v │
|
||
│ │
|
||
│ 最后一位 → s[len(s)-1] │
|
||
│ 最后 N 位 → s[len(s)-N :] │
|
||
│ │
|
||
│ 总原则：切片永远少一位，闭区间要 +1 │
|
||
│ │
|
||
└──────────────────────────────────────────────────┘
|
||
```
|