add: 布隆过滤器删除问题 + 计数布隆过滤器 + 布谷鸟过滤器

docs/algorithm/bloom-filter-deletion.md

@@ -0,0 +1,125 @@
+# 布隆过滤器删除问题
+
+!!! note "💡 一句话概述"
+    标准布隆过滤器不支持删除——因为多个元素共享 bit 位，直接置零会导致假阴性；需要删除能力时，应当换用 Counting Bloom Filter、Cuckoo Filter 或工程层面的替代方案。
+
+---
+
+## 🔑 核心概念
+
+1. **位共享**：多个元素经哈希后可能映射到同一个 bit 位，无法判断某个 `1` 只属于一个元素。
+2. **假阴性禁忌**：布隆过滤器允许假阳性，但绝不允许假阴性——已插入的元素必须能被查到。
+3. **全量重建**：标准布隆过滤器删除元素的唯一可靠方式是丢弃旧过滤器，根据原始数据集重新构建。
+
+---
+
+## 📝 详细说明
+
+### 为什么标准布隆过滤器不能直接删除？
+
+布隆过滤器的本质是一个**位数组（Bit Array）**。插入元素时通过多个哈希函数计算位置并置 `1`。
+
+**问题在于哈希冲突**：假设元素 A 和元素 B 经过哈希计算后，都映射到了第 5 号槽位：
+
+```mermaid
+graph LR
+    A["元素 A"] -->|h₁| S5["bit[5] = 1"]
+    B["元素 B"] -->|h₂| S5["bit[5] = 1"]
+```
+
+- 插入 A → bit[5] = 1
+- 插入 B → bit[5] 依然是 1（已经是 1，不变）
+- **删除 A** → 把 A 映射的槽位（包括 bit[5]）全部清零 → bit[5] = 0
+- **查询 B** → 发现 bit[5] = 0 → **错误判定 B 不存在** ❌
+
+这就是**假阴性（False Negative）**——标准布隆过滤器允许假阳性（没插入但判断存在），但绝不允许假阴性（插入了却判断不存在）。因此，不能通过将位清零来删除元素。
+
+### 假阴性为什么不可接受？
+
+| 错误类型 | 含义 | 布隆过滤器容忍度 | 原因 |
+|---------|------|:---:|------|
+| 假阳性 FP | 元素不存在却判存在 | ✅ 可容忍 | 代价只是多查一次 DB/缓存 |
+| 假阴性 FN | 元素已存在却判不存在 | ❌ 不可容忍 | 数据丢失，业务逻辑根本错误 |
+
+典型场景：用布隆过滤器防缓存穿透——假阳性最多让一个不存在的 key 穿透到 DB；假阴性则会误认为合法用户不存在，直接拒绝服务。
+
+---
+
+## 💻 工程妥协方案
+
+如果不方便更换底层数据结构，以下方案可在业务层规避删除问题：
+
+### 方案 1：双布隆过滤器（白名单 + 黑名单）
+
+维护两个布隆过滤器：`Bloom_White`（白名单）和 `Bloom_Black`（黑名单）。
+
+```mermaid
+graph TD
+    INSERT["插入元素"] --> W["Bloom_White.Add()"]
+    DELETE["删除元素"] --> B["Bloom_Black.Add()"]
+    QUERY["查询元素"] --> QW{"Bloom_White<br/>可能存在?"}
+    QW -->|否| NO["❌ 一定不存在"]
+    QW -->|是| QB{"Bloom_Black<br/>可能存在?"}
+    QB -->|是| DELETED["❌ 已删除"]
+    QB -->|否| YES["✅ 真正存在"]
+```
+
+| 操作 | 做法 |
+|------|------|
+| 插入 | 加入 `Bloom_White` |
+| 删除 | 不修改 `Bloom_White`，将元素加入 `Bloom_Black` |
+| 查询 | `Bloom_White` 判存在 **且** `Bloom_Black` 判不存在 → 才认为真正存在 |
+
+!!! warning "黑名单膨胀"
+    黑名单也会随时间膨胀，需要定期清理或重建黑名单。适合删除量远小于插入量的场景。
+
+### 方案 2：定期全量重建（异步后台任务）
+
+如果删除操作非常低频，或者系统允许一定的延迟：
+
+```mermaid
+sequenceDiagram
+    participant APP as 业务服务
+    participant DB as 数据库（真相源）
+    participant BF as 布隆过滤器
+    participant CRON as 定时任务
+
+    APP->>BF: 正常读写
+    Note over BF: 包含少量"脏"数据
+
+    CRON->>DB: 凌晨低峰：SELECT 有效元素
+    CRON->>BF: 根据真实集合全量重建
+    CRON->>BF: 原子切换新 → 旧
+    Note over BF: 重建完成，数据干净
+```
+
+| 步骤 | 说明 |
+|------|------|
+| 1 | 在内存或数据库中保留**真实的元素集合**（或仅记录删除日志） |
+| 2 | 布隆过滤器负责快速拦截"绝对不存在"的请求 |
+| 3 | 低峰期（如凌晨），根据真实集合异步全量重建布隆过滤器 |
+| 4 | 重建完成后原子切换新旧过滤器 |
+
+!!! tip "关键：原子切换"
+    重建时不要修改旧过滤器，而是构建新的。完成后通过指针或引用替换实现原子切换，避免中间状态。
+
+---
+
+## 📊 方案选型建议
+
+| 场景 | 推荐方案 |
+|------|---------|
+| 删除频繁、不允许全量重建 | [Counting Bloom Filter](counting-bloom-filter.md) 或 [Cuckoo Filter](cuckoo-filter.md) |
+| 用 Redis 等中间件、不方便换结构 | 双布隆过滤器（白名单 + 黑名单） |
+| 删除极低频（如每天删几个） | 定期全量重建 |
+| 对空间敏感、需要删除 | [Cuckoo Filter](cuckoo-filter.md)（比 CBF 更省空间） |
+| 允许假阳性但不允许假阴性 | 任何方案都能满足——选最简单的 |
+
+---
+
+## 🔗 相关链接
+
+- [布隆过滤器](bloom-filter.md) — 基础原理与实现
+- [计数布隆过滤器](counting-bloom-filter.md) — 支持删除的经典变体
+- [布谷鸟过滤器](cuckoo-filter.md) — 支持删除的现代变体
+- [Bloom Filter — Wikipedia](https://en.wikipedia.org/wiki/Bloom_filter) — 假阳性与假阴性数学推导

docs/algorithm/counting-bloom-filter.md

@@ -0,0 +1,259 @@
+# 计数布隆过滤器
+
+!!! note "💡 一句话概述"
+    Counting Bloom Filter 将标准布隆过滤器的位数组升级为计数器数组，从而原生支持删除操作，代价是约 4 倍的空间开销。
+
+---
+
+## 🔑 核心概念
+
+1. **计数器数组（Counter Array）**：每个槽位不再只存 0/1，而是存一个计数值（通常 4 bit 或 8 bit）。
+2. **插入即 +1**：元素映射的 k 个槽位计数器各自加一。
+3. **删除即 -1**：元素映射的 k 个槽位计数器各自减一。
+4. **查询 > 0**：所有映射槽位的计数器均大于零时，判定元素可能存在。
+
+---
+
+## 📝 详细说明
+
+### 与标准布隆过滤器对比
+
+```mermaid
+graph LR
+    subgraph SBF["标准布隆过滤器"]
+        direction TB
+        SB["位数组"] --> SI["插入: 置 1"]
+        SB --> SQ["查询: 全为 1?"]
+        SB --> SD["删除: ❌"]
+    end
+
+    subgraph CBF["计数布隆过滤器"]
+        direction TB
+        CB["计数器数组"] --> CI["插入: +1"]
+        CB --> CQ["查询: 全 > 0?"]
+        CB --> CD["删除: -1 ✅"]
+    end
+
+    SBF -.->|"约 4x 空间"| CBF
+```
+
+| 特性 | 标准布隆过滤器 | 计数布隆过滤器 |
+|------|:---:|:---:|
+| 存储单位 | 1 bit/槽 | 4 bit（或 8 bit）/槽 |
+| 空间开销 | 1x | ~4x（4 bit 计数器） |
+| 插入 | 置 1 | 计数器 +1 |
+| 删除 | ❌ | 计数器 -1 ✅ |
+| 查询 | 所有位 = 1？ | 所有计数器 > 0？ |
+| 假阳性 | 有 | 有（相同概率） |
+| 假阴性 | 无 | 无 |
+
+### 删除原理
+
+以 4 bit 计数器为例（每个槽位可表示 0~15）：
+
+```
+初始状态: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+插入 A（h1=1, h2=5, h3=9）:
+[0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
+
+插入 B（h1=1, h2=3, h3=7）:    ← 注意 h1 与 A 冲突
+[0, 2, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0]
+
+删除 A（h1=1, h2=5, h3=9）→ 各计数器 -1:
+[0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0]
+
+查询 B（h1=1→1, h2=3→1, h3=7→1）→ 全部 > 0 ✅ 仍能正确判断存在
+```
+
+对比标准布隆过滤器：如果直接将 bit[1] 清零，B 的查询就会产生假阴性。
+
+### 计数器溢出风险
+
+4 bit 计数器最大值为 15。如果同一个槽位被超过 15 个元素命中，计数器将溢出归零，导致后续操作出错。
+
+**实际风险极低**：对于 k 个哈希函数、m 个槽位的布隆过滤器，某个特定槽位的计数期望为 $n \cdot k / m$。以 100 万元素、1% 误判率为例（m ≈ 958 万、k ≈ 7），单槽计数期望仅约 0.73，远低于 15。
+
+**保险策略**：
+
+- 使用 4 bit 计数器（0~15）适合绝大多数场景
+- 极端密集场景使用 8 bit 计数器（0~255）
+- 计数器达到上限时视为错误，触发告警或全量重建
+
+---
+
+## 💻 代码示例
+
+### Go 实现
+
+```go
+package countingbloom
+
+import (
+	"hash/fnv"
+	"math"
+)
+
+type CountingBloomFilter struct {
+	counters []uint8  // 计数器数组，每个用 4 bit（低 4 位）
+	k        int      // 哈希函数个数
+	m        uint     // 计数器个数
+}
+
+// New 根据预期元素数和误判率创建计数布隆过滤器
+func New(expectedItems uint, falsePositiveRate float64) *CountingBloomFilter {
+	m := optimalM(expectedItems, falsePositiveRate)
+	k := optimalK(m, expectedItems)
+	return &CountingBloomFilter{
+		counters: make([]uint8, (m+1)/2), // 每个 uint8 存 2 个 4-bit 计数器
+		k:        k,
+		m:        m,
+	}
+}
+
+func optimalM(n uint, p float64) uint {
+	return uint(-float64(n) * math.Log(p) / (math.Ln2 * math.Ln2))
+}
+
+func optimalK(m, n uint) int {
+	return int(math.Round(float64(m) / float64(n) * math.Ln2))
+}
+
+// getCounter 读取第 idx 个 4-bit 计数器
+func (cbf *CountingBloomFilter) getCounter(idx uint) uint8 {
+	byteIdx := idx / 2
+	if idx%2 == 0 {
+		return cbf.counters[byteIdx] & 0x0F // 低 4 位
+	}
+	return cbf.counters[byteIdx] >> 4 // 高 4 位
+}
+
+// setCounter 写入第 idx 个 4-bit 计数器
+func (cbf *CountingBloomFilter) setCounter(idx uint, val uint8) {
+	byteIdx := idx / 2
+	if idx%2 == 0 {
+		cbf.counters[byteIdx] = (cbf.counters[byteIdx] & 0xF0) | (val & 0x0F)
+	} else {
+		cbf.counters[byteIdx] = (cbf.counters[byteIdx] & 0x0F) | ((val & 0x0F) << 4)
+	}
+}
+
+// Add 插入元素
+func (cbf *CountingBloomFilter) Add(data []byte) {
+	for i := 0; i < cbf.k; i++ {
+		pos := cbf.hash(data, i)
+		cur := cbf.getCounter(pos)
+		if cur < 15 { // 防止溢出
+			cbf.setCounter(pos, cur+1)
+		}
+	}
+}
+
+// Remove 删除元素
+func (cbf *CountingBloomFilter) Remove(data []byte) {
+	for i := 0; i < cbf.k; i++ {
+		pos := cbf.hash(data, i)
+		cur := cbf.getCounter(pos)
+		if cur > 0 {
+			cbf.setCounter(pos, cur-1)
+		}
+	}
+}
+
+// Contains 判断元素是否可能存在
+func (cbf *CountingBloomFilter) Contains(data []byte) bool {
+	for i := 0; i < cbf.k; i++ {
+		pos := cbf.hash(data, i)
+		if cbf.getCounter(pos) == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func (cbf *CountingBloomFilter) hash(data []byte, i int) uint {
+	h1 := fnv.New32a()
+	h1.Write(data)
+	hash1 := h1.Sum32()
+	h2 := fnv.New32()
+	h2.Write(data)
+	hash2 := h2.Sum32()
+	return (uint(hash1) + uint(i)*uint(hash2)) % cbf.m
+}
+```
+
+### 使用示例
+
+```go
+package main
+
+import (
+	"fmt"
+
+	cbloom "your-module/countingbloom"
+)
+
+func main() {
+	// 100万元素，1% 误判率
+	cbf := cbloom.New(1_000_000, 0.01)
+
+	// 插入
+	cbf.Add([]byte("user:1001"))
+	cbf.Add([]byte("user:1002"))
+	cbf.Add([]byte("user:1003"))
+
+	fmt.Println("user:1001 exists:", cbf.Contains([]byte("user:1001"))) // true
+	fmt.Println("user:9999 exists:", cbf.Contains([]byte("user:9999"))) // false
+
+	// 删除
+	cbf.Remove([]byte("user:1001"))
+	fmt.Println("user:1001 after delete:", cbf.Contains([]byte("user:1001"))) // false
+
+	// 不存在的元素删除是安全的（计数器不会下溢）
+	cbf.Remove([]byte("user:9999")) // 无副作用
+}
+```
+
+---
+
+## ⚠️ 常见陷阱
+
+!!! warning "计数器溢出"
+    4 bit 计数器上限为 15。当溢出发生时，后续删除操作无法正确递减，可能导致元素永远无法被"判不存在"。生产环境应监控计数器高位是否触及上限。
+
+!!! warning "空间开销是标准布隆的 4 倍"
+    4 bit 计数器 = 标准布隆每个 bit 位 × 4。100 万元素、1% 误判率的标准布隆约 1.14 MB，CBF 约 4.57 MB。如果空间敏感，考虑 [Cuckoo Filter](cuckoo-filter.md)。
+
+!!! warning "删除不存在的元素是"空操作"但不报错"
+    对未插入的元素调用 `Remove`，计数器已经为 0 不会下溢，但也不会给出"元素不存在"的提示。业务层需要额外逻辑确保只在确认存在时才删除。
+
+---
+
+## 🏋️ 练习题
+
+??? question "练习 1：100 万元素、1% 误判率的 CBF 需要多少内存？"
+    标准布隆过滤器 m ≈ 958 万 bit ≈ 1.14 MB。CBF 每个计数器 4 bit，空间为 4 × 958 万 bit ≈ 4.57 MB。
+
+    ??? success "答案"
+        约 **4.57 MB**（4 bit 计数器场景）。是同参数标准布隆过滤器的约 **4 倍**。
+
+??? question "练习 2：如果某个 4 bit 计数器已经等于 15，再插入一个映射到同一槽位的元素会发生什么？"
+    计数器不能超过 15，忽略此次增量。后续删除该元素时计数器仍然 15，无法正确递减。
+
+    ??? success "答案"
+        **计数器溢出**。实现中通常做饱和处理（不再 +1），但这意味着该槽位"锁死"在 15——即使所有映射到该槽的元素都被删除，计数器也不会归零，导致假阳性无法消除。生产环境应监控饱和计数器数量，接近阈值时触发重建。
+
+??? question "练习 3：为什么 CBF 不用 1 bit 计数器（即标准布隆过滤器）？1 bit 计数器"能减到 0"不也行吗？"
+    1 bit 计数器值域只有 {0, 1}。两个元素映射到同一位后，该位为 1；删除其中一个后置 0，另一个元素就查不到了——这正是标准布隆过滤器不能删除的原因。
+
+    ??? success "答案"
+        1 bit 计数器无法区分"被几个元素占用"。值为 1 时可能是 1 个元素映射，也可能是多个元素映射；置 0 后所有占用该位的元素都会受影响。只有用 ≥2 bit 的计数器才能记录"有多少个元素占用了这个槽位"，从而安全地执行 -1 删除。
+
+---
+
+## 🔗 相关链接
+
+- [布隆过滤器](bloom-filter.md) — 标准布隆过滤器原理与实现
+- [布隆过滤器删除问题](bloom-filter-deletion.md) — 核心问题与工程替代方案
+- [布谷鸟过滤器](cuckoo-filter.md) — 空间更优且支持删除的替代方案
+- [Counting Bloom Filter 论文](https://dl.acm.org/doi/10.1145/342009.335363) — L. Fan et al., 2000

docs/algorithm/cuckoo-filter.md

@@ -0,0 +1,327 @@
+# 布谷鸟过滤器
+
+!!! note "💡 一句话概述"
+    Cuckoo Filter 是一种支持动态插入与删除的概率数据结构，空间效率通常优于 Counting Bloom Filter，且查询性能稳定——适合需要频繁增删的场景。
+
+---
+
+## 🔑 核心概念
+
+1. **指纹存储**：不存储位标记，而是存储元素的短指纹（Fingerprint），通常 4~8 bit。
+2. **布谷鸟哈希**：每个元素有 2 个候选桶（Bucket），插入时选择较空的位置；冲突时"踢出"旧元素并重新安置。
+3. **原地删除**：定位到指纹后可直接移除，无需计数器。
+4. **半排序压缩**：每个桶存储多个指纹时可做半排序编码，进一步压缩空间。
+
+---
+
+## 📝 详细说明
+
+### 布谷鸟哈希原理
+
+标准布隆过滤器用"位数组 + 多哈希"做判定；布谷鸟过滤器用的是"桶数组 + 指纹 + 布谷鸟哈希"。
+
+```mermaid
+graph TD
+    subgraph 插入x["插入元素 x"]
+        X["x"] --> FH["fingerprint(x) = 0xA3"]
+        X --> H1["h₁(x) → bucket[3]"]
+        X --> H2["h₂(x) → bucket[7]"]
+        H1 --> CK3{"bucket[3]<br/>有空位?"}
+        CK3 -->|是| INS3["放入 bucket[3]"]
+        CK3 -->|否| CK7{"bucket[7]<br/>有空位?"}
+        CK7 -->|是| INS7["放入 bucket[7]"]
+        CK7 -->|否| KICK["随机踢出 bucket 中一个指纹<br/>被踢出者重新计算候选桶并安置"]
+    end
+```
+
+**踢出（Kick-out）过程**：
+
+1. 元素 x 的两个候选桶都满了
+2. 随机选择一个桶，踢出其中一个已有指纹 y
+3. 用部分关键等式算出 y 的另一个候选桶：$h_2 = h_1 \oplus \text{hash}(fp_y)$
+4. 将 y 放入其另一个候选桶
+5. 若也被占，重复踢出过程（有最大次数限制，超出则判定过滤器已满）
+
+### 部分关键等式
+
+布谷鸟过滤器的精妙之处在于：不需要存储原始元素，只需要指纹就能推导出备选位置：
+
+$$h_2(x) = h_1(x) \oplus \text{hash}(\text{fingerprint}(x))$$
+
+这意味着：
+
+- 从 $h_1$ 和指纹可以推出 $h_2$
+- 从 $h_2$ 和指纹可以推出 $h_1$
+- 无需存原始元素，仅需指纹即可完成查找和重定位
+
+### 删除操作
+
+```mermaid
+graph LR
+    D["删除元素 x"] --> FH["计算 fingerprint(x)"]
+    FH --> H1["检查 bucket[h₁(x)]"]
+    FH --> H2["检查 bucket[h₂(x)]"]
+    H1 --> M1{"找到匹配指纹?"}
+    H2 --> M2{"找到匹配指纹?"}
+    M1 -->|是| RM1["移除该指纹 ✅"]
+    M2 -->|是| RM2["移除该指纹 ✅"]
+    M1 -->|否| M2
+    M2 -->|否| NF["元素不存在 ❌"]
+```
+
+**删除步骤**：
+
+1. 计算 x 的指纹和两个候选桶位置
+2. 在两个候选桶中查找匹配的指纹
+3. 找到则移除，未找到则报告元素不存在
+
+!!! warning "指纹冲突导致的误删"
+    不同元素可能产生相同指纹。如果元素 y 与元素 x 指纹相同且恰好在 x 的候选桶中，删除 x 时可能误删 y 的指纹。这本质上是布谷鸟过滤器的假阳性在删除场景的体现。
+
+---
+
+## 💻 代码示例
+
+### Go 实现
+
+```go
+package cuckoofilter
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math/rand"
+)
+
+const (
+	fingerprintSize = 4       // 4 字节指纹
+	bucketsCount    = 1 << 16 // 桶数量
+	entriesPerBucket = 4      // 每桶 4 个槽位
+	maxKicks       = 500     // 最大踢出次数
+)
+
+type fingerprint [fingerprintSize]byte
+
+type bucket struct {
+	entries [entriesPerBucket]fingerprint
+	used    [entriesPerBucket]bool
+}
+
+type CuckooFilter struct {
+	buckets [bucketsCount]bucket
+	count   int
+}
+
+// New 创建布谷鸟过滤器
+func New() *CuckooFilter {
+	return &CuckooFilter{}
+}
+
+// fp 计算元素指纹
+func fp(data []byte) fingerprint {
+	h := fnvHash(data)
+	var f fingerprint
+	binary.BigEndian.PutUint32(f[:], h)
+	return f
+}
+
+// hash 计算主桶位置
+func hash(data []byte) uint {
+	h := fnvHash(data)
+	return uint(h) % bucketsCount
+}
+
+// altIndex 计算备选桶位置
+func altIndex(idx uint, f fingerprint) uint {
+	h := fnvHash(f[:])
+	return (idx ^ h) % bucketsCount
+}
+
+// Insert 插入元素
+func (cf *CuckooFilter) Insert(data []byte) bool {
+	f := fp(data)
+	i1 := hash(data)
+	i2 := altIndex(i1, f)
+
+	// 尝试放入主桶
+	if cf.insertToBucket(i1, f) {
+		cf.count++
+		return true
+	}
+	// 尝试放入备选桶
+	if cf.insertToBucket(i2, f) {
+		cf.count++
+		return true
+	}
+
+	// 两个桶都满，执行踢出
+	idx := i1
+	if rand.Intn(2) == 0 {
+		idx = i2
+	}
+	for k := 0; k < maxKicks; k++ {
+		// 随机选一个槽位踢出
+		slot := rand.Intn(entriesPerBucket)
+		evicted := cf.buckets[idx].entries[slot]
+		cf.buckets[idx].entries[slot] = f
+		cf.buckets[idx].used[slot] = true
+
+		// 被踢出的指纹寻找备选位置
+		idx = altIndex(idx, evicted)
+		if cf.insertToBucket(idx, evicted) {
+			cf.count++
+			return true
+		}
+		f = evicted
+	}
+	// 超过最大踢出次数，过滤器已满
+	return false
+}
+
+func (cf *CuckooFilter) insertToBucket(idx uint, f fingerprint) bool {
+	b := &cf.buckets[idx]
+	for i := 0; i < entriesPerBucket; i++ {
+		if !b.used[i] {
+			b.entries[i] = f
+			b.used[i] = true
+			return true
+		}
+	}
+	return false
+}
+
+// Lookup 查询元素是否可能存在
+func (cf *CuckooFilter) Lookup(data []byte) bool {
+	f := fp(data)
+	i1 := hash(data)
+	i2 := altIndex(i1, f)
+	return cf.findInBucket(i1, f) || cf.findInBucket(i2, f)
+}
+
+func (cf *CuckooFilter) findInBucket(idx uint, f fingerprint) bool {
+	b := &cf.buckets[idx]
+	for i := 0; i < entriesPerBucket; i++ {
+		if b.used[i] && b.entries[i] == f {
+			return true
+		}
+	}
+	return false
+}
+
+// Delete 删除元素
+func (cf *CuckooFilter) Delete(data []byte) bool {
+	f := fp(data)
+	i1 := hash(data)
+	i2 := altIndex(i1, f)
+
+	if cf.removeFromBucket(i1, f) || cf.removeFromBucket(i2, f) {
+		cf.count--
+		return true
+	}
+	return false // 元素不存在（或假阳性误删）
+}
+
+func (cf *CuckooFilter) removeFromBucket(idx uint, f fingerprint) bool {
+	b := &cf.buckets[idx]
+	for i := 0; i < entriesPerBucket; i++ {
+		if b.used[i] && b.entries[i] == f {
+			b.used[i] = false
+			return true
+		}
+	}
+	return false
+}
+
+func fnvHash(data []byte) uint32 {
+	h := fnv.New32a()
+	h.Write(data)
+	return h.Sum32()
+}
+```
+
+### Redis 布谷鸟过滤器
+
+```bash
+# 创建布谷鸟过滤器
+CF.RESERVE my_cuckoo 1000000
+
+# 插入
+CF.ADD my_cuckoo user:1001
+
+# 查询
+CF.EXISTS my_cuckoo user:1001   # → 1
+
+# 删除 ✅ 原生支持
+CF.DEL my_cuckoo user:1001
+
+# 批量插入
+CF.MADD my_cuckoo user:1002 user:1003 user:1004
+
+# 查看容量信息
+CF.INFO my_cuckoo
+```
+
+---
+
+## 📊 与其他过滤器对比
+
+| 特性 | 布隆过滤器 | Counting Bloom | Cuckoo Filter |
+|------|:---:|:---:|:---:|
+| 插入 | O(k) | O(k) | 均摊 O(1)，最坏 O(maxKicks) |
+| 查询 | O(k) | O(k) | O(1) — 只查 2 个桶 |
+| 删除 | ❌ | ✅ | ✅ |
+| 假阳性 | 有 | 有 | 有（相似量级） |
+| 空间效率（每元素） | ~9.6 bit（1% FP） | ~38 bit（4 bit 计数器） | ~12.6 bit（1% FP） |
+| 接近满载 | 误判率上升 | 误判率上升 | 插入失败（可感知） |
+| 动态扩容 | 需 Scalable BF | 需类似机制 | 需重建 |
+
+!!! tip "空间效率优势"
+    在相同假阳性率下，Cuckoo Filter 比 Counting Bloom Filter 省约 3 倍空间；与标准布隆过滤器相比略有开销，但换来了删除能力。
+
+---
+
+## ⚠️ 常见陷阱
+
+!!! warning "接近满载时插入性能下降"
+    当利用率超过 95% 时，踢出链变长，单次插入可能需要数百次踢出。建议负载不超过 80~85%，超出后扩容重建。
+
+!!! warning "重复插入需谨慎删除"
+    同一元素插入多次会产生多个指纹副本。每次 `Delete` 只移除一个副本。如果插入了 3 次只删除 1 次，查询仍会返回"存在"。
+
+!!! warning "指纹冲突导致误删"
+    不同元素可能有相同指纹且落入相同桶。删除元素 A 时可能误删元素 B 的指纹。指纹越长（4→8 bit），误删概率越低，但空间开销增加。
+
+!!! warning "不支持扩容"
+    桶数组大小在建时确定。超过容量后只能全量重建更大的过滤器。与标准布隆过滤器不同，布谷鸟过滤器无法像 Scalable Bloom Filter 那样串联扩容。
+
+---
+
+## 🏋️ 练习题
+
+??? question "练习 1：Cuckoo Filter 的部分关键等式 $h_2 = h_1 \oplus \text{hash}(fp)$ 有什么好处？"
+    只需存储指纹，不需要存储原始元素或完整的两个桶索引。从任意一个桶索引和指纹就能算出另一个桶索引。
+
+    ??? success "答案"
+        **省空间**：不需要额外存储两个候选桶位置。只需一个桶索引 + 指纹就能用 XOR 推导出另一个候选位置。同时也使踢出重定位逻辑更简洁——被踢出的指纹只需知道自己当前在哪个桶，就能算出另一个桶。
+
+??? question "练习 2：为什么 Cuckoo Filter 接近满载时插入性能会下降？"
+        可用空位越来越少，新插入的元素更容易遇到两个候选桶都满的情况，需要更多次踢出才能成功安置。
+
+    ??? success "答案"
+        随着利用率升高，空位减少导致踢出链变长。极端情况下，踢出可能形成环（A 踢 B，B 踢 C，C 又踢 A），触发最大踢出次数限制后插入失败。这是"布谷鸟哈希"的固有特性——在负载因子约 93% 时，期望查找时间趋于无穷大。生产中应监控负载率，超过 80% 时考虑重建。
+
+??? question "练习 3：100 万元素、1% 假阳性率，Cuckoo Filter 需要多少空间？比 CBF 省多少？"
+    Cuckoo Filter 每元素约 12.6 bit。CBF 每元素约 38 bit（4 bit 计数器 × 约 9.6 槽位/元素）。
+
+    ??? success "答案"
+        Cuckoo Filter：100 万 × 12.6 bit ≈ **1.5 MB**。CBF：100 万 × 38 bit ≈ **4.6 MB**。Cuckoo 节省约 **3 倍**空间，同时支持删除。
+
+---
+
+## 🔗 相关链接
+
+- [布隆过滤器](bloom-filter.md) — 标准布隆过滤器基础
+- [布隆过滤器删除问题](bloom-filter-deletion.md) — 核心问题与工程方案
+- [计数布隆过滤器](counting-bloom-filter.md) — 另一种支持删除的方案
+- [Cuckoo Filter 原论文](https://www.cs.cmu.edu/~dga/papers/cuckoo-conext2014.pdf) — Fan et al., CoNEXT 2014
+- [RedisBloom CF 命令](https://redis.io/docs/stack/bloom/) — Redis 原生布谷鸟过滤器

mkdocs.yml

@@ -94,4 +94,7 @@ nav:
   - 算法:
     - algorithm/index.md
     - 布隆过滤器: algorithm/bloom-filter.md
+    - 布隆过滤器删除问题: algorithm/bloom-filter-deletion.md
+    - 计数布隆过滤器: algorithm/counting-bloom-filter.md
+    - 布谷鸟过滤器: algorithm/cuckoo-filter.md
     - HeavyKeeper: algorithm/heavykeeper.md