软件工程术语库·编码与设计篇

术语定位：术语 = 你和 AI 的共享词汇表，用公认术语写 prompt 比自造词高效得多。

本篇目录

〇、为什么要有这份术语库
一、代码质量与重构
- [1.1 代码坏味道类（Code Smells）](#1.1 代码坏味道类（Code Smells） "#s1-1")
- [1.2 复杂度类](#1.2 复杂度类 "#s1-2")
- [1.3 质量度量类](#1.3 质量度量类 "#s1-3")
- [1.4 原则类](#1.4 原则类 "#s1-4")
- [1.5 通用编程基础](#1.5 通用编程基础 "#s1-5")
二、软件架构与设计模式
- [2.1 架构原则类](#2.1 架构原则类 "#s2-1")
- [2.2 设计模式类（GoF 经典）](#2.2 设计模式类（GoF 经典） "#s2-2")
- [2.3 面向对象与模块化类](#2.3 面向对象与模块化类 "#s2-3")
- [2.5 分层对象模型](#2.5 分层对象模型 "#s2-4")
- [2.4 数据与状态类](#2.4 数据与状态类 "#s2-5")
八、并发与多线程
十三、数据结构与算法

〇、为什么要有这份术语库

写命令/Skill 时，检查维度用一个「公认术语词」就够（如 Complexity、Duplication），因为 AI 脑子里已经有这些概念 ------你只需说对术语，它就能调动已有知识去查，比自造词高效。关键：

用「公认术语」→ Claude 的完整理解去查 → 更全面（模糊的正确）
用「自造词」→ 理解有歧义 → 效果差
用「具体规则」→ 会漏掉规则没写到的场景（精确的错误）来源：公认术语来自软件工程的经典知识（代码坏味道、SOLID、架构评估框架、各领域官方规范），不是发明，是行业标准。

一、代码质量与重构

1.1 代码坏味道类（Code Smells）

Code Smell：代码的表层信号，暗示更深层设计问题。==
Duplicated Code（重复代码）：相同逻辑在多个地方出现。需求变更时漏改一处就产生不一致 bug，是最常见、重构收益最大的坏味道。
Long Method（长方法）：方法过长、承载多个职责（常见阈值 >20-30 行）。越长越难理解与测试，标准重构是 Extract Method。
Large Class（大类）：单个类承载过多字段与职责（阈值 >300 行或 >5 项职责）。违反单一职责、难以复用，重构是 Extract Class。
Feature Envy（特性依恋）：一个方法对另一类的数据「兴趣」超过自己所在类。说明方法放错归属、推高耦合，重构是 Move Method。
God Object（上帝对象）：一个类集中了过多互不相关的职责。严重违反 SRP、极难测试维护；判断法------说不清它做什么而不用「和」字，就是做太多。
Spaghetti Code（意大利面条代码）：控制流被 goto/标志位/深层嵌套搅乱、依赖缠结。极难阅读调试演进，必须系统重构。
Magic Number（魔数）：代码中直接出现无语义的数字（86400、0.15）。语义不明、改一处易漏多处，应替换为具名常量。
Dead Code（死代码）：不再被执行的代码（未用变量/导入/分支/类）。白白增加阅读维护成本、误导读者，删除是零风险收益。
Shotgun Surgery（散弹式修改）：改一个需求要改许多分散的类。高耦合典型症状，一处改动波及全系统。
Long Parameter List（长参数列表）：方法参数超过 3-4 个。调用易错、难维护，重构为参数对象或方法对象。
Primitive Obsession（基本类型偏执）：过度使用基本类型表示领域概念（如用 String 表示手机号、金额）。缺失类型校验、业务逻辑散落，应封装为值对象。
Comments（过多注释） ：用注释解释代码在做什么。注释会和代码漂移，好代码应自解释，注释只说「为什么」不说「是什么」。

1.2 复杂度类

Cyclomatic Complexity（圈复杂度）：用「决策点数 + 1」度量线性独立路径数量。客观、可自动计算、与缺陷率正相关，团队质量阈值通常 <10。
Cognitive Complexity（认知复杂度）：度量读懂代码的脑力成本，对嵌套层数叠加惩罚。比圈复杂度更贴近人读代码的真实体验，业界常双指标并用（圈 <10、认知 <15）。
Big-O Notation（大 O 记号）：描述算法运行时间/内存随输入规模增长的上界（O(1)/O(n)/O(n²)...）。提供与硬件无关的性能语言，用于选数据结构和算法。
Coupling（耦合）：模块间相互依赖的程度。高耦合使系统脆弱、改动牵连广，低耦合是良好设计标志。
Cohesion（内聚）：模块内部元素共同服务单一职责的程度。高内聚模块健壮、可复用、行为可预测，与低耦合共同构成设计质量基石。
N+1 Query Problem：先查 N 条主记录、再对每条各发一次关联查询，共 N+1 次 SQL。最常见性能坏味道，用 eager loading/join 消除。
Nesting Depth（嵌套深度）：if/循环的嵌套层数。深嵌套是认知复杂度主要来源，需早返回或提取方法化解。
Circular Dependency（循环依赖）：模块 A 依赖 B、B 又反向依赖 A。破坏模块边界、难理解难测试，依赖卫生必须清除。
Dependency Direction（依赖方向）：模块间依赖箭头应指向稳定/抽象层。方向错误导致底层改动向上游连锁扩散。
Dependency Hygiene（依赖卫生） ：依赖整洁度检查（import 是否都用、有无循环依赖、版本是否冲突）。冗余依赖拖慢构建、加大变更风险。

1.3 质量度量类

Code Coverage（代码覆盖率） ：白盒度量，测试执行期间代码行/分支被运行的比例。衡量「代码被执行多少」，但不衡量测试质量------高覆盖是必要非充分条件。
Test Coverage（测试覆盖率）：广义度量，包含需求覆盖、场景覆盖、代码覆盖，不局限于代码执行比例。保证「该测的功能测了」，与代码覆盖率互补。
Technical Debt（技术债）：为短期交付写的「不太对」的代码像借债，不偿还要付「利息」。不是坏代码别名，而是有意的速度-质量权衡，关键要定期偿还。
Code Review（代码审查）：人对代码 diff 做人工评审。提供静态分析给不了的上下文判断，是缺陷进入主干前的人工防线。
Static Analysis（静态分析）：不执行程序、解析源码找问题（SAST）。每次提交规模化、零成本发现已知坏模式（SQL 注入/死代码/硬编码密钥），但有误报、无法评估业务意图。
Dynamic Analysis（动态分析）：运行程序时收集执行信息找问题（如内存泄漏、性能瓶颈）。能发现静态分析无法覆盖的运行时问题。
Maintainability（可维护性）：代码易被修改、扩展、修复的程度。软件生命周期 80% 成本在维护阶段，是最重要质量维度之一。
Code Readability（代码可读性）：代码被他人快速理解的程度。可读的代码才敢改、少出错。
Self-Documenting Code（自解释代码）：代码本身清晰到无需额外注释说明逻辑。减少注释与代码漂移失配。
Naming Convention（命名规范） ：标识符（类/方法/变量）的统一命名规则。命名是代码可读性的基础，统一规范降低团队沟通成本。

1.4 原则类

DRY（Don't Repeat Yourself）：每份知识必须在系统中只有单一、权威的表示。重复是需求变更时漏改的 bug 温床（违反的英文叫 WET）。
KISS（Keep It Simple, Stupid）：多数系统简单才能工作得最好。简单代码易读易改，不必要的复杂是缺陷与成本的来源。
YAGNI（You Aren't Gonna Need It）：只在真正需要时才实现，绝不提前做。超前功能白付开发测试文档成本，且大概率永远用不上。
SOLID：架构判断提供统一词汇（SRP/OCP/LSP/ISP/DIP）。
Single Responsibility（SRP）：一个类只有一个职责、只有一个变更理由。职责单一使模块更小更易测，是消除 God Object 的依据。
Open/Closed（OCP）：对扩展开放、对修改关闭。不改旧代码就不引入新 bug。
Liskov Substitution（LSP）：子类应能无副作用替换父类。违反导致多态失效（经典反例：Square 继承 Rectangle）。
Interface Segregation（ISP）：胖接口应拆成客户端专属小接口。不强迫使用者实现用不到的方法。
Dependency Inversion（DIP）：高层不依赖低层，都依赖抽象。用抽象隔开高低层，使核心不被底层实现绑架。
Law of Demeter（迪米特法则/最少知识原则） ：对象只与「直接的朋友」交谈。防止 a.getB().getC().doX() 链式穿透，实现低耦合。
Separation of Concerns（SoC，关注点分离）：把不同职责分到独立模块，一次只处理一个关注点。降低耦合提升复用，分层架构的根基。
Least Privilege（最小权限原则）：只授予完成任务所需的最小权限。缩小攻击面，降低误操作影响。
Fail Fast（快速失败）：错误发生时立即暴露、终止，不允许带病运行。问题早发现早修复，避免错误扩散到下游。
Composition Over Inheritance（组合优于继承） ：优先用对象组合实现复用，少用类继承。继承是强耦合，组合更灵活、更易测试。

1.5 通用编程基础

Serialization / Deserialization（序列化/反序列化）：把对象转成可存储/传输的字节流/JSON，反序列化是反向还原。跨进程通信、存储、网络传输的基础。
Generics（泛型）：参数化类型，让类/方法可以适配多种类型而不牺牲类型安全。代码复用、类型检查在编译期完成，避免强制类型转换。
Reflection（反射）：程序在运行时可以获取类信息、调用方法、访问字段。框架实现的基础（DI、JSON序列化、注解处理），但性能低、破坏封装。
Annotation（注解）：给代码加元数据标记，可在编译期或运行时读取处理。框架配置、代码生成、静态检查的基础（如@Override、@Inject）。
Lambda Expression（Lambda表达式）：匿名函数，可作为参数传递。函数式编程的基础，简化回调、集合操作代码。
Closure（闭包）：函数可以捕获其定义时所在作用域的变量。回调、函数式编程的核心特性。
Exception（异常）：程序运行时的错误事件，分受检异常（必须捕获）和非受检异常（运行时异常）。统一错误处理机制，避免错误被忽略。
Callback（回调）：把函数作为参数传入，事件发生时被调用。异步编程的基础，但多层回调会导致回调地狱。
Immutable Object（不可变对象）：创建后状态不能修改的对象。天生线程安全、可共享、无副作用，是并发编程最佳实践。
First-Class Function（一等函数）：函数可以作为参数传递、作为返回值、赋值给变量。函数式编程的基础特性。
Type System（类型系统）：静态类型在编译期检查，动态类型在运行时检查。静态类型提前发现错误、IDE支持好；动态类型灵活、开发快。
Garbage Collection（GC，垃圾回收）：运行时自动回收不再使用的内存。避免手动内存管理的泄漏、野指针问题，但会有STW停顿。
Memory Leak（内存泄漏）：不再使用的对象仍被引用无法回收。长期运行会导致OOM，是服务端和移动端常见问题。
Stack Overflow（栈溢出）：调用栈超过最大深度，通常是无限递归导致。递归代码必须设置终止条件。

二、软件架构与设计模式

2.1 架构原则类

Architecture（架构）：系统高级结构------组件及其关系的设计。架构选错是最高成本的技术债，后期重构代价指数级增长。
Layered Architecture（分层架构）：按职责分横向层级（表现层/业务层/数据层），依赖单向向下。结构直观、职责清晰，最普遍的分层方式；缺点是易导致业务依赖数据层，难满足依赖倒置。
Onion Architecture（洋葱架构）：领域模型在最内层，外层只能向内依赖，核心不依赖任何外部框架。核心不受基础设施更换影响，测试性极强。
Hexagonal Architecture（六边形架构/端口适配器）：核心业务居中，端口定义接口、适配器连接外部（数据库/API/UI）。与洋葱架构同源思想------核心零外部依赖、独立演进，天然支持 TDD。
Clean Architecture（整洁架构）：融合洋葱/六边形思想，依赖规则永远指向内层抽象。统一了分层架构的依赖方向，是后端架构的主流指导思想。
Module Boundaries（模块边界）：模块间明确定义的依赖与交互接口。边界画错，后期拆成微服务改造成本极高。
Microservices（微服务）：拆成一组小型独立服务，独立部署、独立伸缩、围绕业务能力组织。独立部署/故障隔离/团队自治；代价是分布式复杂度（网络延迟、数据一致性、运维成本）显著上升，符合康威定律。
Modular Monolith（模块化单体）：单个部署单元，但内部按业务模块严格划分边界、模块间仅通过接口通信。兼顾单体的简单和微服务的边界清晰，是中小团队的最优架构选择，未来可平滑拆分微服务。
Monolith（单体架构）：所有组件打包成一个可部署单元。项目初期开发速度最快；规模增长后易形成大泥球，成为迭代瓶颈。
Event-Driven Architecture（EDA，事件驱动架构）：组件响应事件通知，发布者不关心谁接收。松耦合、可伸缩、一对多扇出；代价是难调试、引入最终一致性。
Client-Server（客户端-服务器）：客户端发起请求、服务器响应。最基础的分布式交互模型，简单可预测（REST 是典型实现）。
Progressive Disclosure（渐进式披露）：UX 领域术语，先展示核心信息，按需加载细节；在 LLM 工程中指按需加载知识、不一次性全量注入。LLM 场景可显著节省 token，避免上下文干扰。
Pipeline（流水线架构）：任务拆成串行阶段，每阶段输出是下阶段输入。分解复杂任务、便于编排与责任隔离，是 CI/CD 和多 Agent 工作流的基础。
CQRS（命令查询职责分离）：将写操作（命令）和读操作（查询）用不同模型实现。读写性能可分别优化，适合读写比悬殊的场景；代价是增加复杂度。
Event Sourcing（事件溯源）：不存对象当前状态，存所有状态变更事件，通过重放事件得到当前状态。完整审计轨迹、可回溯任意时间点状态；适合金融、账务系统。
Conway's Law（康威定律） ：系统设计的结构，会复制组织的沟通结构。设计架构前先设计团队结构，微服务边界应和团队边界对齐。

2.2 设计模式类（GoF 经典）

Singleton（单例模式）：确保一个类只有一个实例，提供全局访问点。适合共享唯一资源（配置、连接池）；但滥用会造成全局可变状态、难以测试，现代工程优先用 DI 容器管理单例。
Factory Method（工厂方法）：定义创建对象的接口，让子类决定实例化哪个类。解耦「创建」与「使用」，符合开闭原则。
Abstract Factory（抽象工厂）：提供接口创建一系列相关对象，无需指定具体类。适合跨平台、多产品族的对象创建。
Builder（建造者模式）：将复杂对象的构建与表示分离，分步构建对象。解决长参数列表问题，适合构建配置复杂的对象。
Observer（观察者模式）：一对多依赖，被观察对象变化时自动通知所有依赖者。实现事件/发布-订阅解耦（前端 Hooks、事件总线都是此思想）。
Strategy（策略模式）：定义一族可互换算法，封装起来使它们可互相替换。运行时切换行为而不改调用方，消除大量 if-else。
Adapter（适配器模式）：把一个类的接口转换成客户端期望的另一个接口。不修改已有代码即可复用能力，解决接口不兼容问题。
Decorator（装饰器模式）：动态给对象附加新职责，不改变其结构。避免「子类爆炸」，可组合叠加可选功能（如 Java IO 流、Python 装饰器）。
Facade（外观模式）：为复杂子系统提供统一的简化接口。降低客户端耦合、隐藏内部复杂度。
Proxy（代理模式）：为其他对象提供代理以控制访问。实现延迟加载、权限控制、日志增强（AOP、RPC 客户端都是此模式）。
Chain of Responsibility（责任链模式）：把请求处理者连成一条链，请求沿链传递直到被处理。解耦发送者和处理者，可动态添加处理者（中间件、拦截器都是此模式）。
Template Method（模板方法模式）：父类定义算法骨架，子类实现具体步骤。复用公共流程，子类只改差异部分。
State Pattern（状态模式）：把对象的每个状态封装成类，状态改变时改变行为。消除大量状态判断if-else，符合开闭原则。
Command Pattern（命令模式）：把请求封装成对象，可排队、撤销、日志记录。实现操作撤销、任务队列、宏命令。
Repository Pattern（仓储模式）：用类集合接口在领域层和数据层之间做中介，封装数据访问逻辑。隔离数据库细节、集中查询逻辑、便于单元测试 mock。
Unit of Work（工作单元模式）：跟踪一个业务事务内的所有对象变更，一次性提交。保证事务一致性，避免多次数据库提交。
Dependency Injection（DI，依赖注入）：把对象的依赖从外部传入，而非内部创建。实现松耦合与可测试性，是现代框架的核心能力。
Inversion of Control（IoC，控制反转） ：把程序流程控制权交给框架（「Don't call us, we'll call you」）。框架的本质（Claude Code Hooks、Spring 容器都是 IoC 实现）；DI 是 IoC 最常见的实现方式。

2.3 面向对象与模块化类

Module（模块）：高内聚、对外暴露清晰接口的程序单元。让代码可独立开发、测试、替换。
Package（包）：相关程序单元的集合与命名空间容器。逻辑分组、防命名冲突、控制可见性。
Namespace（命名空间）：一组名称的容器，用于隔离标识符。大型系统防同名冲突。
Abstraction（抽象）：只暴露必要特征、隐藏无关实现细节。让开发者聚焦本质，降低复杂度。
Encapsulation（封装）：把数据与操作数据的方法捆绑成类，隐藏内部状态。内部实现可独立改动而不影响调用方。
Inheritance（继承）：子类继承父类的属性和方法，实现代码复用。OO 三大特性之一，但强耦合，现代工程优先用组合。
Polymorphism（多态）：不同类型对同一接口呈现不同行为。让代码面向抽象编程，符合开闭原则。
Cross-cutting Concerns（横切关注点）：跨越多个模块的通用功能（鉴权/日志/限流/事务）。需用中间件/AOP 集中处理，否则会散落在业务代码中造成重复。
Value Object（值对象）：通过属性值定义身份、不可变的对象（如金额、日期）。避免基本类型偏执，封装业务校验，线程安全。
Aggregate（聚合） ：DDD 概念，一组相关对象的集合，作为数据修改的单元。保证业务一致性边界，聚合内强一致，聚合间最终一致。

2.5 分层对象模型

POJO（Plain Old Java Object）：普通Java对象，没有继承特殊类、实现特殊接口。简单、可测试，是所有分层对象的基础。
PO（Persistent Object，持久化对象）：和数据库表一一对应的对象，DAO层使用。隔离数据库表结构和业务层。
DTO（Data Transfer Object，数据传输对象）：跨进程/跨层传输数据的对象，只包含字段没有业务逻辑。减少接口调用次数、隔离内部领域模型。
VO（View Object/Value Object）：展示层对象，对应前端页面需要的数据；也可指值对象。封装展示数据，不暴露内部字段。
BO（Business Object，业务对象）：业务层对象，封装业务逻辑。业务逻辑的载体，可组合多个PO。
DAO（Data Access Object，数据访问对象） ：数据访问层对象，提供数据库CRUD接口。隔离业务层和数据库实现，便于替换和测试。

2.4 数据与状态类

State Management（状态管理）：应用状态的存储、更新、订阅机制，分客户端状态（UI 本地态）和服务端状态（API 数据）。混用两类状态是前端最常见的架构错误。
Caching（缓存）：把昂贵计算或查询的结果暂存到高速存储。性能优化头号手段；代价是引入一致性和缓存失效问题。
TTL（Time-To-Live，存活时间）：缓存/数据的有效时长，过期自动失效。实现最终一致性的简单机制。
Cache Invalidation（缓存失效）：数据变更后更新或删除对应缓存，保证数据正确。缓存正确性完全取决于失效策略，是缓存最难的部分。
Cache Penetration（缓存穿透）：查询不存在的数据，请求直接打到数据库。恶意攻击可拖垮数据库，需用布隆过滤器或空值缓存解决。
Cache Avalanche（缓存雪崩）：大量缓存同时过期，所有请求打到数据库。会导致数据库压力骤增甚至宕机，需过期时间加随机值解决。
Idempotency（幂等性）：同一操作重复执行多次，结果与执行一次相同。网络不可靠时幂等使重试无害（支付、webhook 必须保证幂等）。
Race Condition（竞态条件）：并发访问共享资源且无同步，结果取决于执行时序。产生随机错误且极难复现调试。
Deadlock（死锁）：两个或多个线程互相等待对方持有的资源，永久阻塞。必须同时满足互斥、持有并等待、不可剥夺、循环等待四个条件才会发生。
Dead Letter Queue（死信队列）：多次消费失败的消息移入的专用队列。防止坏消息无限重试阻塞主队列，便于事后排查。
Transaction（事务）：把多步读写操作捆绑为原子单元，满足 ACID 特性。保证多步操作的数据一致性；跨服务事务需用 Saga 模式，牺牲强一致性换取可用性。
Optimistic Locking（乐观锁）：假设冲突很少，更新时检查版本号，冲突则重试。无锁、性能高，适合读多写少场景。
Pessimistic Locking（悲观锁）：假设冲突经常发生，操作前先加锁。保证强一致，适合写多冲突多场景，但性能低。

八、并发与多线程

Thread（线程）：操作系统调度的最小执行单元，一个进程包含多个线程。并发执行任务，提升 CPU 利用率。
Process（进程）：资源分配的最小单位，有独立内存空间，进程间不共享内存。进程隔离保证一个进程崩溃不影响其他进程。
Coroutine（协程）：用户态轻量级线程，由程序调度，不依赖操作系统内核。创建切换成本极低，可轻松创建上万个，是现代异步编程的主流方案。
Context Switch（上下文切换）：CPU 切换执行线程时保存/恢复寄存器状态的过程。线程太多会导致大量时间花在切换上，反而降低性能。
Mutex/Lock（互斥锁）：保证同一时间只有一个线程访问共享资源。解决竞态条件，但使用不当会导致死锁。
Deadlock（死锁）：见 2.4 节。
Race Condition（竞态条件）：见 2.4 节。
Thread Safety（线程安全）：多线程环境下代码能正确执行，没有竞态问题。并发代码的核心质量要求。
Immutable Object（不可变对象）：创建后状态不能修改的对象。天生线程安全，无需加锁，是并发编程的最佳实践之一。
Synchronized（同步）：保证方法/代码块同一时间只有一个线程执行。最基础的线程安全手段，但性能较低。
Volatile：保证变量的可见性和有序性，不保证原子性。一个线程写、多个线程读的场景下无需加锁。
Atomic Operation（原子操作）：不可中断的操作，要么全完成要么全不完成。无锁实现线程安全，性能高于加锁。
Thread Pool（线程池）：预先创建一组线程，复用执行任务，避免频繁创建销毁。降低线程创建开销，控制并发数，防止资源耗尽。
Future/Promise：表示异步计算结果的占位符，可在未来获取结果。异步任务结果传递的标准抽象。
Async/Await：协程/JS 的异步语法，用同步写法写异步代码。避免回调地狱，异步代码可读性接近同步代码。
Memory Barrier（内存屏障）：保证指令可见性和有序性的硬件/软件机制。理解 Java/Kotlin 内存模型、volatile 原理的基础。
Happens-Before：Java 内存模型的偏序规则，保证一个操作的结果对另一个操作可见。判断并发代码是否正确的理论基础。

十三、数据结构与算法

Array（数组）：连续内存存储的同类型元素集合，随机访问 O(1)。最基础的数据结构，是其他结构的基础。
Linked List（链表）：节点通过指针连接，内存不连续，插入删除 O(1)，访问 O(n)。实现队列、栈、哈希表冲突链的基础。
Stack（栈）：后进先出（LIFO）的数据结构。函数调用、表达式求值、括号匹配、深度优先搜索的基础。
Queue（队列）：先进先出（FIFO）的数据结构。任务调度、消息队列、广度优先搜索的基础。
Hash Table（哈希表/散列表）：通过哈希函数把 key 映射到数组位置，平均查找 O(1)。最常用的数据结构，键值查询性能极高，是字典、Map 的底层。
Tree（树）：分层的非线性数据结构，有根节点、子节点。文件系统、数据库索引、DOM 的基础结构。
Binary Tree（二叉树）：每个节点最多两个子节点的树。二叉搜索树、平衡树的基础。
Binary Search Tree（BST，二叉搜索树）：左子树 < 根 < 右子树，查找平均 O(log n)。有序数据的快速查找，平衡 BST 是 TreeMap/TreeSet 的底层。
Balanced Tree（平衡树）：AVL、红黑树等，自动保持树高平衡，避免退化成链表。保证最坏情况 O(log n) 性能，是有序 Map 的标准实现。
Heap（堆）：完全二叉树，分大顶堆和小顶堆，取最大/最小值 O(1)。优先队列、Top K 问题、堆排序的基础。
Graph（图）：由顶点和边组成的非线性结构，表示多对多关系。社交网络、路径规划、依赖关系的建模基础。
Trie（前缀树/字典树）：专门处理字符串匹配的树，公共前缀共享节点。搜索提示、敏感词过滤、IP 路由最长前缀匹配。
Bloom Filter（布隆过滤器）：空间效率极高的概率型数据结构，判断元素「一定不存在或可能存在」。解决缓存穿透、海量数据去重，有极低误判率。
LRU Cache（最近最少使用缓存）：缓存满时淘汰最久没访问的数据。最常用的缓存淘汰策略。
Sorting Algorithm（排序算法）：冒泡、插入、选择、快排、归并、堆排等。最基础的算法，不同场景选不同算法，工程中常用语言内置排序。
Binary Search（二分查找）：有序数组中每次折半查找，O(log n)。有序数据查找的最优算法，思想可用于各种二分问题。
Recursion（递归）：函数调用自身，把大问题拆成小问题。树、图、分治算法的基础，但要注意栈溢出和重复计算；尾递归可被编译器优化，避免栈溢出。
Dynamic Programming（动态规划）：把大问题拆成重叠子问题，存储子问题结果避免重复计算。最优解问题的核心思想，如背包、最长公共子序列。
Greedy Algorithm（贪心算法）：每一步选当前最优，期望得到全局最优。简单高效，但需要证明贪心选择性质。
Divide and Conquer（分治法）：把问题分成子问题递归解决，再合并结果。快排、归并排序、MapReduce 的核心思想。
BFS（广度优先搜索）：图/树按层遍历，用队列实现。最短路径、层序遍历的基础。
DFS（深度优先搜索）：图/树一条路走到底再回溯，用栈/递归实现。连通性、拓扑排序、回溯算法的基础。
Backtracking（回溯法）：试探性搜索，走不通就回退。排列组合、N 皇后、解数独等问题的标准解法。
Time Complexity（时间复杂度）：算法运行时间随输入规模增长的趋势。评估算法效率的核心指标。
Space Complexity（空间复杂度）：算法运行需要的额外内存随输入规模增长的趋势。评估算法内存占用。
Skip List（跳表）：多层有序链表，查找/插入/删除平均O(log n)。Redis有序集合的底层实现，比平衡树实现简单。
Bitmap（位图）：用bit位表示数据是否存在，极省空间。海量数据去重、签到、布隆过滤器的基础。
Sliding Window（滑动窗口）：双指针维护一个窗口，在数组/字符串上滑动。解决子串、子数组问题的经典思路，O(n)时间。
Two Pointers（双指针）：两个指针在数组上移动，相向或同向。有序数组两数之和、去重、链表环检测等问题的最优解。