是小鬏鬏啊1. 算法口诀：程序员的高效记忆术
在编程竞赛和算法面试中，我们常常需要快速回忆各种经典算法的实现细节。那些看似简单的排序、查找、图论算法，在高压环境下却容易突然"断片"。这时候，一套精心设计的算法口诀就能成为救命稻草。
算法口诀不是死记硬背的教条，而是将复杂逻辑转化为朗朗上口的记忆锚点。就像乘法口诀表之于算术，好的算法口诀能让你在键盘上飞舞时，不用频繁查阅文档就能调出正确的算法模板。我收集整理这套口诀的过程中，发现它们往往具备三个特征：押韵易记、逻辑映射准确、关键步骤无遗漏。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 排序算法七言绝句
2.1 冒泡排序：轻浮者先起
"相邻比较勤交换，一轮下来定一端"
这句口诀准确描述了冒泡排序的核心机制。每次内层循环比较相邻元素，将较大元素逐步"浮"到数组末端。经过n-1轮后，就像烧开水时气泡上浮一样，所有元素按序排列。
实际操作时要注意：
- 外层循环控制轮次（n-1次）
- 内层循环范围随轮次递减（每轮减少末尾已排序部分）
- 设置提前退出标志（当某轮无交换时终止）
python复制def bubble_sort(arr):
n = len(arr)
for i in range(n-1):
swapped = False
for j in range(n-1-i):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
swapped = True
if not swapped: break
2.2 快速排序：分而治之王者
"选基准，分两边，递归调用记心间"
这12个字浓缩了快速排序的精髓。选择基准值（pivot）后，将数组分为小于基准和大于基准的两部分，然后对子数组递归执行相同操作。
关键实现细节：
- 基准选择常用三数取中法（首、中、尾元素的中位数）
- 分区时使用双指针法效率最高
- 递归基例处理（子数组长度≤1时返回）
python复制def quick_sort(arr):
if len(arr) <= 1: return arr
pivot = median_of_three(arr[0], arr[len(arr)//2], arr[-1])
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
3. 图论算法三字经
3.1 Dijkstra最短路径：步步为营
"起零余无穷，选最小松弛，标永久前行"
这15个字完整描述了Dijkstra算法的执行流程。从起点开始（距离设为0），每次选择当前距离最小的节点进行松弛操作，并将其标记为永久节点。
实现时的注意事项：
- 使用优先队列（堆）维护待处理节点
- 需要记录前驱节点以重建路径
- 不适用于含负权边的图
python复制import heapq
def dijkstra(graph, start):
distances = {node: float('inf') for node in graph}
distances[start] = 0
heap = [(0, start)]
while heap:
current_dist, current_node = heapq.heappop(heap)
if current_dist > distances[current_node]:
continue
for neighbor, weight in graph[current_node].items():
distance = current_dist + weight
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(heap, (distance, neighbor))
return distances
3.2 拓扑排序：依赖解耦
"入度为零先处理，减邻入度再判断"
这个口诀描述了拓扑排序的典型实现方式。每次选择入度为0的节点输出，并减少其邻接节点的入度，直到所有节点都被处理或发现环。
实际应用场景：
- 任务调度系统
- 课程选修顺序
- 软件包依赖解析
python复制from collections import deque
def topological_sort(graph):
in_degree = {u: 0 for u in graph}
for u in graph:
for v in graph[u]:
in_degree[v] += 1
queue = deque([u for u in in_degree if in_degree[u] == 0])
result = []
while queue:
u = queue.popleft()
result.append(u)
for v in graph[u]:
in_degree[v] -= 1
if in_degree[v] == 0:
queue.append(v)
if len(result) != len(graph):
return None # 存在环
return result
4. 动态规划五言诀
4.1 背包问题：取舍之道
"物重价二维表，装不装比大小"
这10个字概括了0-1背包问题的核心解法。构建二维DP表格，每个单元格表示在当前重量限制下，考虑前i个物品时的最大价值，通过比较装入和不装入当前物品的价值来决定状态转移。
优化技巧：
- 空间复杂度可优化为O(W)
- 使用滚动数组技巧
- 完全背包问题只需调整遍历顺序
python复制def knapsack(weights, values, capacity):
n = len(weights)
dp = [[0]*(capacity+1) for _ in range(n+1)]
for i in range(1, n+1):
for w in range(1, capacity+1):
if weights[i-1] <= w:
dp[i][w] = max(values[i-1] + dp[i-1][w-weights[i-1]], dp[i-1][w])
else:
dp[i][w] = dp[i-1][w]
return dp[n][capacity]
4.2 最长公共子序列：轨迹追踪
"相同左上加一，不同取大继承"
这句口诀描述了LCS问题的状态转移规则。当字符相同时，值为左上单元格加一；不同时，取上方或左方单元格的较大值。
实际编码建议：
- 可以只使用两行数组节省空间
- 通过反向追踪可以重建具体序列
- 时间复杂度O(mn)难以优化
python复制def longest_common_subsequence(text1, text2):
m, n = len(text1), len(text2)
dp = [[0]*(n+1) for _ in range(m+1)]
for i in range(1, m+1):
for j in range(1, n+1):
if text1[i-1] == text2[j-1]:
dp[i][j] = dp[i-1][j-1] + 1
else:
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
return dp[m][n]
5. 树形结构记忆歌
5.1 二叉树遍历：序位分明
"前序根在前，中序根在中，后序根最后，层次用队列"
这20个字清晰区分了四种二叉树遍历方式。前中后序指的是根节点的访问时机，层次遍历则需要借助队列实现。
非递归实现要点：
- 前序使用栈，先压右子节点
- 中序需要指针配合栈
- 后序可用反转前序的方法
python复制# 前序遍历非递归实现
def preorder_traversal(root):
if not root: return []
stack, result = [root], []
while stack:
node = stack.pop()
result.append(node.val)
if node.right: stack.append(node.right)
if node.left: stack.append(node.left)
return result
5.2 红黑树：平衡之道
"根叶皆黑不红连，黑高相同保平衡"
这14个字总结了红黑树的五个性质。根节点和叶子节点(NIL)是黑色，没有相邻的红色节点，从任一节点到其每个叶子的路径包含相同数量的黑色节点。
插入修复的三种情况：
- 叔节点为红色：重新着色
- 叔节点为黑色且当前节点是右孩子：左旋
- 叔节点为黑色且当前节点是左孩子：右旋后重新着色
python复制# 红黑树左旋操作示例
def left_rotate(tree, x):
y = x.right
x.right = y.left
if y.left != tree.nil:
y.left.parent = x
y.parent = x.parent
if x.parent == tree.nil:
tree.root = y
elif x == x.parent.left:
x.parent.left = y
else:
x.parent.right = y
y.left = x
x.parent = y
6. 位操作妙用口诀
6.1 常用位运算技巧
"与或非异要记牢，移位乘除效率高"
这个口诀强调了位运算在性能优化中的重要性。合理使用位运算可以替代部分算术运算，获得显著的性能提升。
经典应用场景：
- 判断奇偶：x & 1
- 交换两数：a ^= b; b ^= a; a ^= b
- 取绝对值：(x ^ (x >> 31)) - (x >> 31)
python复制# 使用位运算实现快速乘除法
def multiply_by_7(x):
return (x << 3) - x # 8x - x = 7x
def divide_by_4(x):
return x >> 2
6.2 布隆过滤器：概率之美
"多哈希位数组，查可能有，无必无"
这13个字准确描述了布隆过滤器的特性。使用多个哈希函数映射到位数组，查询时若所有位都为1则可能存在，任一为0则必定不存在。
设计要点：
- 位数组大小与预期元素数量成正比
- 哈希函数数量影响误判率
- 不支持元素删除
python复制import mmh3
from bitarray import bitarray
class BloomFilter:
def __init__(self, size, hash_num):
self.size = size
self.hash_num = hash_num
self.bit_array = bitarray(size)
self.bit_array.setall(0)
def add(self, string):
for seed in range(self.hash_num):
result = mmh3.hash(string, seed) % self.size
self.bit_array[result] = 1
def contains(self, string):
for seed in range(self.hash_num):
result = mmh3.hash(string, seed) % self.size
if self.bit_array[result] == 0:
return False
return True
7. 字符串处理要诀
7.1 KMP算法：失配不回溯
"部分匹配建表，失配时跳前缀"
这12个字概括了KMP算法的核心思想。通过预处理构建部分匹配表，当字符失配时，利用表中信息跳过不可能匹配的位置。
关键理解点：
- 部分匹配值是最长前后缀长度
- 时间复杂度O(m+n)远优于暴力法
- 适合处理含有大量重复模式的字符串
python复制def build_lps(pattern):
lps = [0] * len(pattern)
length = 0
i = 1
while i < len(pattern):
if pattern[i] == pattern[length]:
length += 1
lps[i] = length
i += 1
else:
if length != 0:
length = lps[length-1]
else:
lps[i] = 0
i += 1
return lps
def kmp_search(text, pattern):
lps = build_lps(pattern)
i = j = 0
while i < len(text):
if text[i] == pattern[j]:
i += 1
j += 1
if j == len(pattern):
return i - j
else:
if j != 0:
j = lps[j-1]
else:
i += 1
return -1
7.2 正则表达式：模式之力
"元字符组量词，贪婪懒惰要分清"
这个口诀提醒我们正则表达式中三个核心概念：元字符、字符组和量词，以及贪婪与懒惰匹配模式的区别。
高效使用技巧：
- 预编译正则表达式提升性能
- 合理使用非捕获组(?:)
- 避免灾难性回溯
python复制import re
# 匹配HTML标签内容（非贪婪模式）
html = "<div>content1</div><div>content2</div>"
pattern = re.compile(r'<div>(.*?)</div>')
matches = pattern.findall(html) # ['content1', 'content2']
8. 并发编程顺口溜
8.1 生产者-消费者：缓冲协调
"队列作缓冲，互斥防竞争，条件变量控等待"
这16个字描述了生产者-消费者问题的经典解法。使用队列作为缓冲区，互斥锁保护共享资源，条件变量协调生产消费节奏。
实现注意事项：
- 循环队列可避免内存浪费
- 双条件变量提升效率
- 需要处理队列满/空边界条件
python复制import threading
import queue
import time
def producer(q, count):
for i in range(count):
item = f"item-{i}"
q.put(item)
print(f"Produced {item}")
time.sleep(0.1)
def consumer(q, count):
for _ in range(count):
item = q.get()
print(f"Consumed {item}")
time.sleep(0.2)
q = queue.Queue(maxsize=5)
threading.Thread(target=producer, args=(q, 10)).start()
threading.Thread(target=consumer, args=(q, 10)).start()
8.2 读者-写者问题：读写平衡
"读者共享计数，写者独占资源"
这12个字点明了读者-写者问题的解决方案核心。允许多个读者同时访问，但写者需要独占资源。
常见变体：
- 读者优先
- 写者优先
- 公平竞争
python复制from threading import Lock, Semaphore
class ReaderWriter:
def __init__(self):
self.read_count = 0
self.mutex = Lock() # 保护read_count
self.resource = Lock() # 读写锁
self.turnstile = Semaphore(1) # 用于写者优先
def reader_acquire(self):
self.turnstile.acquire()
self.turnstile.release()
self.mutex.acquire()
self.read_count += 1
if self.read_count == 1:
self.resource.acquire()
self.mutex.release()
def reader_release(self):
self.mutex.acquire()
self.read_count -= 1
if self.read_count == 0:
self.resource.release()
self.mutex.release()
def writer_acquire(self):
self.turnstile.acquire()
self.resource.acquire()
def writer_release(self):
self.resource.release()
self.turnstile.release()
9. 数据库索引口诀
9.1 B+树：检索之基
"多路平衡排序树，数据全在叶子处"
这14个字总结了B+树的两大特点：多路平衡搜索结构，所有数据记录都存储在叶子节点。
设计考量：
- 节点大小通常与磁盘页对齐
- 高扇出减少IO次数
- 范围查询效率极高
sql复制-- 创建B+树索引的SQL示例
CREATE INDEX idx_user_name ON users(last_name, first_name);
9.2 哈希索引：精准定位
"哈希函数定位置，等值查询快如风"
这个口诀突出了哈希索引的特点：通过哈希函数直接定位数据，适合等值查询但不支持范围查询。
适用场景：
- 内存表
- 等值查询频繁的场景
- 不需要排序或范围查询的情况
sql复制-- MySQL中使用哈希索引
CREATE TABLE memory_table (
id INT PRIMARY KEY,
data VARCHAR(100)
) ENGINE=MEMORY;
CREATE INDEX hash_idx ON memory_table(data) USING HASH;
10. 口诀记忆方法论
10.1 口诀创作原则
"关键步骤押韵记，逻辑映射要准确"
这个口诀本身就在示范如何创作好口诀。好的算法口诀应该抓住关键步骤，通过押韵增强记忆，同时确保与原始逻辑准确对应。
创作技巧：
- 提取算法最独特的特征
- 使用动词描述操作流程
- 保持简短（最好不超过20字）
10.2 口诀使用建议
"理解在先记忆辅，实战检验修正补"
这14个字强调了口诀的正确使用方式。必须先理解算法原理，口诀只是辅助记忆工具，最终要通过实践来验证和调整。
我在算法教学中发现，学生自己创作的口诀往往比现成的更有效。建议尝试为常用算法编写个人版本的口诀，这个过程本身就是深度理解的过程。例如，有位学生为Dijkstra算法创作的口诀是："起零余无限，小堆取最小，松弛邻更新"，既准确又有个性特色。