UML 建模 · 系统整理

一、UML 在软考中的定位

UML 建模是下午试题三（15 分必答），考法以补充类名、补充多重度、补充用例关系、补充消息名为主，极少要求从零画整张图。

软件设计师涉及的 UML 图按用途分为三类：

• 静态建模：类图、对象图、用例图。
• 动态建模：序列图（时序图/顺序图）、通信图、状态图、活动图。
• 物理建模：构件图、部署图。

下午题高频图种是类图和用例图，序列图次之；状态图和活动图偶尔出现，通常只要求补状态名或转换条件。上午选择题则可能涉及图的分类（静态/动态/物理）和接口、部署图的使用阶段等边角知识。

二、UML 类图的六大关系（核心考点）

类图是 UML 的核心，描述系统的静态结构——类的属性、方法以及类与类之间的关系。六大关系必须从符号、语义、代码表现、强度排序四个维度同时掌握。

1. 六种关系总表

符号速记：依赖虚线开口，关联实线直连；聚合空心菱，组合实心菱；泛化实线空心三角，实现虚线空心三角。菱形永远在整体端。

2. 强度排序（易错，但考得隐蔽）

六种关系的耦合强度从强到弱为：泛化 > 组合 > 聚合 > 关联 > 实现 ≈ 依赖。绑定越紧，一方的修改对另一方的影响越大。这个排序在选择题中可能以“哪种关系耦合最强/最弱”的形式出现。

3. 聚合 vs 组合（最高频辨析）

两者的区分只看生命周期是否同步：

• 聚合：整体消失，部分仍然存在。如“部门”与“员工”，部门撤销，员工调到其他部门继续存在。
• 组合：整体消失，部分随之销毁。如“订单”与“订单项”，订单删除，订单项也不复存在。

考试中如果题干强调“同生共死”“不可分割”“随整体销毁”，选组合；如果强调“可独立存在”“可脱离整体”，选聚合。

4. 依赖的判定（容易漏判）

依赖是最弱的关系，表现为临时使用：一个类的方法把另一个类的对象作为参数、局部变量或返回值，就构成依赖。如果两个类之间只是“方法里用了一下”，没有成员变量长期持有，就画依赖虚线，而不是关联实线。

5. 类框与可见性

类框通常分三层：类名、属性、方法。可见性符号：+ 公开（public），- 私有（private），# 保护（protected）。

下午题注意：业务分析层面的类图不应出现 getter/setter 等纯技术方法，应列出与业务规则相关的核心操作。

三、多重度（类图必考填空）

多重度写在关联线两端，表示“一个类的实例可以与另一个类的多少个实例相关联”。考试中常以填空形式出现，要求补齐 (1)~(4) 处的多重度。

判定方法（最关键） ：站在每一端，看对方。

• 站在 A 端看 B：一个 A 对象对应几个 B 对象？把答案写在 B 端。
• 站在 B 端看 A：一个 B 对象对应几个 A 对象？把答案写在 A 端。

易错点：只标一边、把“0”漏掉（新系统刚上线可以没有订单）、把 1..* 和 0..* 搞混。题干中出现“一个……可以对应多个……”或“至少一个”的描述，直接对应到两端的多重度。

四、用例图

用例图描述参与者、用例以及它们之间的关系，用于获取需求和指导测试。下午题常考“补充参与者名、补充用例名、判断用例之间的关系”。

1. 基本图形

• 参与者（Actor） ：火柴人，画在系统边界之外。可以是人、硬件或其他系统扮演的角色。“时间”不能作为参与者。
• 用例：椭圆，内写“动词 + 名词”的用例名（如“借书”“还书”）。用例必须对参与者有可观测的完整结果，不能把内部步骤拆成独立用例（“验证密码”不是用例，“登录”才是）。
• 系统边界：可选矩形框包围所有用例，参与者画在框外。

2. 四种关系与箭头方向（最大陷阱）

箭头口诀：“包箭被，扩箭基”——include 箭头指向被包含的用例；extend 箭头指向基础（被扩展） 的用例。

3. include 与 extend 的语义区分

• include：把多个用例的公共行为抽出来，必然执行。如“借书”和“还书”都需要“验证借书证”，把“验证借书证”抽成被包含用例。
• extend：扩展用例是可选的、条件性的，基础用例本身是完整的，只有扩展点被激活时才执行扩展用例。如“还书”时如果超期才触发“计算罚款”。

答题判断：题干说“必须”“一定”“公共步骤”→ include；说“可选”“如果”“特殊情况下”→ extend。

五、序列图（时序图）

序列图是交互图，强调对象之间消息传递的时间顺序。下午题常考“补充对象名、补充消息名、补充消息顺序”，上午题常考消息类型和生命线。

1. 三大核心元素

• 对象：矩形框，格式为“对象名 : 类名”，两者都可省略。发起交互的对象通常放在最左边。
• 生命线：从对象框底部垂直向下的虚线，代表对象在交互中的存在时间。
• 激活期（控制焦点） ：生命线上的细长矩形，表示对象执行一个操作的时间段。生命线是虚线，激活期是长条，不能混淆。

2. 消息类型（高频辨析）

• 同步消息：实心三角箭头，发送者等待接收者处理完成（如客户端上传文件后等服务器确认）。
• 异步消息：空心三角箭头，发送者不等待返回，继续执行。
• 返回消息：虚线 + 开口箭头，表示方法调用返回结果。

时间方向自上而下，消息按发生的先后顺序从上到下排列。

六、其他图种（低频，认识即可）

• 状态图：描述一个对象在生命周期内的状态变迁，常考补状态名和转换条件。
• 活动图：描述流程和并行行为，常考补活动结点名称。
• 部署图：通常在实施阶段使用，考图分类时可能涉及。

七、下午题题型与答题方法

题型一：补充类名

题干给出类名清单（表 3-1）和类图框架，要求把类名填入空缺的类框。方法：读题干中每个类的职责描述，与清单中的类名逐一匹配；先填职责最明确的类，用排除法处理剩余空缺。

题型二：补充多重度

按“站在每一端看对方”的方法逐一判定。题干中的数量词（“一个”“多个”“至少一个”“可以没有”）是直接线索。两端都要标，不能只标一边。

题型三：判断或补充类图关系

看两个类之间是“临时使用”（依赖）、“长期持有”（关联）、“整体—部分”（聚合/组合，看生命周期）还是“父子继承”（泛化）。符号要严格对应：菱形在整体端、三角指父类/接口。

题型四：补充用例名/参与者名，判断用例关系

参与者从题干中的“人/部门/外部系统”提取，用题干原词。用例名用“动词+名词”，不要拆内部步骤。关系判断用“必须/公共”→ include，“可选/如果”→ extend，箭头方向对照“包箭被，扩箭基”。

题型五：补充序列图的消息名或对象名

消息名通常对应接收对象类中的方法名；对象名对应类名。结合题干描述的操作步骤，按时间顺序从上到下补全。

答题规范

• 类名、用例名、消息名用题干原词，不要自己发明。
• 多重度写标准形式（1、0..*、1..*），不要写“多个”这种口语。
• 关系符号画标准：菱形在整体端、泛化三角指父、include/extend 箭头方向不能反。

八、高频易错点汇总

1. 聚合/组合菱形方向反：菱形必须在整体端，不是部分端。
2. 把组合和聚合的生命周期语义搞反：组合是同生共死，聚合是可分离。
3. include 与 extend 箭头方向搞反：记住“扩箭基”——extend 指向基础用例。
4. 把“可选/条件”画成 include：可选行为必须用 extend。
5. 多重度只标一边或漏标“0”：两端都要标，0..* 的“0”不能省。
6. 依赖与关联混淆：临时使用（参数/局部变量）是依赖，长期持有（成员变量）是关联。
7. 泛化和实现混用：继承父类用实线空心三角，实现接口用虚线空心三角。
8. 把内部步骤拆成用例：用例必须对参与者有完整可观测结果，“验证密码”不是用例。
9. 参与者画进系统边界内：参与者一定在外部。
10. 序列图生命线与激活期混淆：虚线是生命线（对象存在），细长矩形是激活期（对象忙碌）。

九、UML 答题检查清单

第一步：符号与方向

• 类图：菱形在整体端？泛化三角指父类/接口？泛化实线、实现虚线？
• 用例图：include 箭头指向被包含用例？extend 箭头指向基础用例？
• 序列图：同步消息实心三角、异步消息空心三角、返回消息虚线？

第二步：标注

• 多重度两端都标了吗？“0”有没有漏？
• 用例关系的构造型 《include》 / 《extend》 写了吗？
• 类框的类名、属性、方法层级是否合理？

第三步：语义

• 聚合 vs 组合看生命周期：同生共死是组合，可分离是聚合。
• include vs extend 看必然性：必须执行是 include，有条件才执行是 extend。
• 依赖 vs 关联看持续性：临时使用是依赖，成员变量持有是关联。

第四步：用词

• 类名、用例名、消息名是否用了题干原词？
• 有没有把内部步骤拆成用例？
• 参与者是否在系统边界之外？

十、UML 背诵清单（直接背）

1. 六大关系符号：依赖虚线开口，关联实线直连；聚合空心菱，组合实心菱；泛化实线空心三角，实现虚线空心三角。
2. 菱形在整体端，泛化三角指父类/接口。
3. 强度排序：泛化 > 组合 > 聚合 > 关联 > 实现 ≈ 依赖。
4. 聚合 vs 组合：生命周期同步是组合，可分离是聚合。
5. 依赖：方法参数/局部变量/返回值中使用，临时关系。
6. 多重度：1、0..1、0..*、1..*；站在每一端看对方，两端都标。
7. 用例关系箭头：包箭被，扩箭基——include 指被包含，extend 指基础。
8. include = 必须/公共行为；extend = 可选/条件触发。
9. 用例名“动词+名词”，不拆内部步骤；参与者必须在系统边界外。
10. 序列图：对象名:类名；生命线是虚线，激活期是长条；同步实心三角，异步空心三角，返回虚线开口。
11. 答题用题干原词，不自己发明名称。
12. 业务类图不塞 getter/setter，只列业务核心操作。

十一、UML 速记口诀

类图六关系：依赖虚线箭，关联实线连；聚合空心菱，组合实心菱；泛化实线三角指父，实现虚线三角指接口；菱形永远在整体端，生命周期分聚合组合。

用例四关系：关联实线指用例，包含虚线箭头指被包，扩展虚线箭头指基础，泛化空心三角指父类。包箭被，扩箭基；必须 include，可选 extend。

多重度：站一端看另一端，两端都标不漏零；同生共死是组合，可脱整体是聚合。

序列图：对象在上线向下，同步实心异步空，返回虚线开口箭，激活长条命是虚。

十二、UML 与 DFD、ER 的区分（防止混淆）

关键区分：UML 的矩形是类，ER 的矩形是业务实体，DFD 的矩形是系统外部实体；UML 中菱形只作为聚合/组合的端点符号，ER 中菱形是联系本身；UML 的箭头有方向语义，ER 的连线不带箭头。

把以上内容按“六大关系→多重度→用例图→序列图→题型→易错点”的顺序过一遍，再拿历年真题的 UML 题练手，重点练 “多重度两端判定” 和 “include/extend 箭头方向” ，这两条是 UML 下午题最高频的采分点和丢分点。

ER 实体-联系图 · 系统整理

一、ER 图是什么

ER 图（Entity-Relationship Diagram，实体-联系图）是概念设计阶段的工具，用图形方式描述业务中的实体、属性和联系。它回答三个问题：业务中有哪些对象、每个对象有哪些特征、对象之间是什么关系。

ER 图是下午试题二（15分必答）的核心，通常与“E-R 图转关系模式、判断主键外键、判断范式”结合考查。考试中很少要求从零画完整 ER 图，更多是补充缺失的联系或属性，然后把图转换成关系模式。

二、ER 图的三种基本元素

ER 图只有三种基本符号，形状必须标准，命名和标注规则必须遵守。

各元素详解

实体

• 业务中需要长期管理的对象，用封闭矩形表示。
• 命名用名词，如“客户”“订单”“商品”“学生”“课程”。
• 矩形四边全封，与 DFD 的外部实体形状相同，但语义不同：ER 的实体是业务对象，DFD 的外部实体是系统边界之外的数据源点。

属性

• 描述实体或联系的特征，用椭圆表示。
• 用无向边（不带箭头的实线）连接到所属实体或联系。
• 主键标注：能唯一标识实体的属性（主键），在椭圆内属性名下方画一条实线下划线。例如“学号”加下划线表示它是学生实体的主键。
• 外键标注：通常用虚下划线标注（下午题关系模式填空时常用实下划线标主键）。
• 属性连线不能带箭头，带箭头是高频错误。

联系

• 表示实体之间的业务关联，用菱形表示。
• 命名用动词或动词短语，如“选修”“预订”“属于”“供应”。
• 用无向边分别连接到相关实体。
• 联系类型必须标在连线旁（不是写在菱形里），用 1:1、1:n、m:n 表示。

三、三种联系类型及画法

1:1（一对一）

• 标注方式：菱形两侧连线旁都标 1（或 1:1）。
• 示例：班级与班长——一个班只有一个班长，一个班长只在一个班。
• 画法：班级 —1— ◇属于◇ —1— 班长

1:n（一对多）

• 标注方式：连接到“1端”实体的线旁标 1，连接到“多端”实体的线旁标 n 或 m。
• 示例：部门与员工——一个部门有多名员工，一名员工只属于一个部门。部门旁标 1，员工旁标 n。
• 画法：部门 —1— ◇拥有◇ —n— 员工
• 注意：“1”端和“n”端不能反，“1”在少的一端，“n”在多的一端。

m:n（多对多）

• 标注方式：菱形两侧连线旁分别标 m 和 n。
• 示例：学生与课程——一个学生选多门课，一门课被多个学生选。学生旁标 m，课程旁标 n。
• 画法：学生 —m— ◇选修◇ —n— 课程

联系类型标注的三个关键

1. 标在连线旁，不是写在菱形里面。
2. 不用箭头，ER 图用无向边加数字标注，不用箭头表示方向。
3. 两端都要标，不能只标一端。

四、联系自身的属性（高频丢分点）

属性不只能属于实体，联系本身也可以有属性。

• 示例：“学生”与“课程”的“选修”联系，属性“成绩”描述的是“某个学生选修某门课程”这件事，应画一个椭圆连接到菱形上，而不是连到学生或课程实体上。
• 判断方法：题干中出现“数量、日期、成绩、时间、金额”这类描述关系状态的词，基本就是联系属性。
• 经典错误：把“成绩”画成学生或课程的属性，而不是选修联系的属性。

五、E-R 图转关系模式（必背规则）

这是下午题第二题的核心得分点，三种联系类型的转换规则必须条件反射。

转换规则详解

1:1 转换

• 两种做法：把一方主键放进另一方作外键，或两表合并。
• 考试中通常选择“把一方主键放入另一方”，具体放哪一方看题干语义（通常把可选性低的一方主键放入另一方）。

1:n 转换

• 1端主键放入n端作外键，这是唯一正确方向。
• 例如部门与员工：员工表里加“部门号”作外键，而不是部门表里加“员工号”。
• 方向搞反是高频错误。

m:n 转换

• 必须单独建表，不能把一方主键塞进另一方。
• 联系表的字段 = 双方主键 + 联系自身属性。
• 联系表的主键 = 双方主键的组合。
• 双方主键在联系表中各自也是外键，分别参照两个实体表。
• 示例：学生选课，单独建“选修（学号，课程号，成绩）”，主键是（学号，课程号），学号和课程号各自是外键。

主键与外键判定

主键判定：

• 题干出现“唯一标识”“编号”“身份证号”的，基本是主键候选。
• 订单表的主键通常是“订单编号”，而不是“客户编号 + 商品编号”的组合（除非题意明确订单号不唯一）。
• m:n 联系表的主键是双方主键的组合。

外键判定：

• 如果 A 表里出现了 B 表的主键，它就是外键。
• m:n 联系表中，双方主键的组合是主键，同时各自也是外键，分别参照两个实体表。
• 1:n 转换中，n 端表中的 1 端主键是外键。

答题格式：关系模式写成 表名（主键加下划线，外键用波浪线或文字说明），并在答案中明确写出“主键是XX，外键是XX，参照XX表”。

六、范式判定（送分题）

范式判定通常与关系模式转换结合考查，判断转换后的关系模式属于第几范式。

判定方法

• 1NF：看有没有“多值属性”或“复合属性”，有就不满足1NF。
• 2NF：先找主键。如果主键是联合主键（多个属性组合），看有没有非主属性只依赖其中一部分。有则不是2NF。
• 3NF：看有没有“A→B，B→C”且B不是候选键的情况。有则是传递依赖，不是3NF。
• 考试常见答案：转换后的关系模式通常能达到3NF；如果题干强调“存在传递依赖”，则答案是2NF。

范式一句话

1NF 列不可分；2NF 消除部分依赖；3NF 消除传递依赖。

七、考试题型与答题方法

题型一：补充 ER 图中的联系或属性

问法：“根据题干说明，补充ER图中缺失的联系”“指出某联系的类型”“补充某实体的属性”。

方法：

• 读题干，找“A和B之间是什么关系”的描述，判断联系类型（1:1、1:n、m:n）。
• 联系类型标在连线旁，两端都要标。
• 如果题干说“某关系有某属性”（如“订单有订单日期”），把属性画成椭圆连到菱形上。

题型二：将 ER 图转换为关系模式

问法：“将ER图转换为关系模式”“补充关系模式中的空缺”“指出每个关系模式的主键和外键”。

方法：

• 按“1:1、1:n、m:n”三种规则逐一转换。
• 1:n 把1端主键放n端；m:n 单独建表，主键为组合。
• 主键加下划线，外键明确写出参照关系。
• 答案格式：表名（主键，属性1，属性2，外键），并注明主键和外键。

题型三：判断范式

问法：“该关系模式属于第几范式”“是否存在部分依赖/传递依赖”。

方法：

• 先找主键，再看非主属性对主键的依赖关系。
• 有部分依赖→1NF；有传递依赖→2NF；都没有→3NF。
• 答题时写出判断依据，如“因为存在非主属性对联合主键的部分依赖，所以不是2NF”。

题型四：补充关系模式中的空缺

问法：“补充(a)(b)处的属性”“指出空缺处应填什么”。

方法：

• 看关系模式的已有字段，缺的通常是外键或联系自身属性。
• 如果缺的是外键，从相关实体表的主键中找。
• 如果缺的是联系属性（如“成绩”“数量”），从题干描述中找。

答题规范

• 关系模式写成 表名（属性1，属性2，……），主键加下划线。
• 明确写出“主键是XX，外键是XX，参照XX表”。
• 范式判定要写出依据（部分依赖/传递依赖）。
• 用题干原词命名实体、属性和联系，不要自己发明名称。

八、高频易错点汇总

1. 形状画错：实体画成椭圆、属性画成矩形、联系画成矩形。
2. 联系类型漏标或标错位置：1:n 必须标在连线旁，且“1”端和“n”端不能反。
3. 联系属性错挂实体：成绩、数量、日期这类描述“关系”的属性，必须挂到菱形上。
4. 主键漏下划线：主键属性必须加实线下划线。
5. 属性连线带箭头：属性与实体/联系之间用无向边，不要画箭头。
6. 1:n 转换方向搞反：必须是1端主键放入n端，不能反过来。
7. m:n 忘记单独建表：m:n 联系必须单独建一张表，不能把一方主键塞进另一方。
8. m:n 建表后主键漏组合：联系表的主键必须是双方主键的组合，不能只用其中一方。
9. 外键漏标或标错参照：外键必须明确参照哪个实体表。
10. 范式判定只写结论不写依据：要写出“存在部分依赖/传递依赖”作为判断理由。
11. 实体命名用动词：实体必须是名词（“订单”不是“下订单”）。
12. 联系命名用名词：联系通常是动词（“选修”不是“选课关系”）。

九、ER 答题检查清单

答完 ER 题，按以下顺序自查：

第一步：形状

• 实体是封闭矩形？
• 属性是椭圆？
• 联系是菱形？
• 属性连线是无向边（不带箭头）？

第二步：标注

• 联系类型（1:1、1:n、m:n）标在连线旁了吗？
• 两端都标了吗？“1”端和“n”端没反吧？
• 主键属性加下划线了吗？
• 联系自身的属性挂到菱形上了吗？

第三步：转换

• 1:n 是否把1端主键放进了n端？
• m:n 是否单独建表了？
• 联系表的主键是否是双方主键的组合？
• 双方主键在联系表中是否都标了外键？
• 每个关系模式的主键和外键都明确写出了吗？

第四步：范式

• 先找主键，再看非主属性对主键的依赖。
• 有部分依赖→1NF；有传递依赖→2NF；都没有→3NF。
• 判断依据写出来了吗？

十、ER 背诵清单（直接背）

1. 三种元素：实体（矩形）、属性（椭圆）、联系（菱形）。
2. 命名规则：实体名词、属性名词、联系动词。
3. 属性连线：无向边，不带箭头。
4. 主键标注：属性名下方实线下划线。
5. 联系类型：1:1、1:n、m:n，标在连线旁，两端都标，不用箭头。
6. 联系属性：描述关系状态的属性（成绩、数量、日期）挂到菱形上。
7. 1:1 转换：任一方主键放入另一方作外键（或合并）。
8. 1:n 转换：1端主键放入n端作外键，方向不能反。
9. m:n 转换：必须单独建表，字段=双方主键+联系属性，主键=双方主键组合，双方主键各自也是外键。
10. 主键判定：题干“唯一标识”“编号”“身份证号”是主键候选。
11. 外键判定：A表出现B表主键，它就是外键。
12. 范式口诀：1NF列不可分；2NF消除部分依赖；3NF消除传递依赖。
13. 答题格式：表名（主键加下划线，属性，外键），明确写出主键和外键参照关系。
14. 范式答题：写出判断依据（部分依赖/传递依赖），不能只写结论。

十一、ER 速记口诀

实体矩形属性椭圆，联系菱形在中间；
联系类型标线旁，主键属性下划线。
联系属性挂菱形，m:n 单独建表记心间；
1:n 把1端主键放n端，主外键判定看编号。
1NF列不可分，2NF消部分，3NF消传递；
转换先找主键，再判依赖，最后写清参照关系。

十二、ER 与 DFD 的区分（防止混淆）

核心区分：ER 图的矩形是业务实体，DFD 的矩形是系统外部实体；ER 图连线不带箭头，DFD 数据流带箭头；ER 图有菱形联系，DFD 没有菱形。

把以上内容按“符号→联系类型→转换规则→范式→题型→易错点”的顺序过一遍，再拿历年真题的数据库设计题练手，重点练“m:n 单独建表”和“1:n 方向不能反”，这两条是 ER 题最高频的采分点和丢分点。

DFD 数据流图 · 系统整理

一、DFD 是什么

DFD（Data Flow Diagram，数据流图）是一种结构化分析工具，用图形方式描述系统的数据流动和加工过程。它回答四个问题：数据从哪里来、经过什么加工、存到哪里、最后输出给谁。

DFD 只关心数据流，不关心控制流、时序和判断条件。它是下午试题一（15分必答）的固定题型。

二、DFD 的四个基本元素

DFD 只有四种符号，必须条件反射地识别和画对。

各元素详解

外部实体

• 系统边界之外的人、组织或外部系统。
• 同一实体可在图中不同位置多次出现，角落加斜线标记。
• 外部实体之间不能直连，必须经过加工中转。
• 顶层图中外部实体与系统加工之间的数据流，必须原样出现在0层图中（父子平衡）。

加工

• 对数据执行变换或处理的功能单元。
• 编号从 P1 开始（顶层图的整体系统加工为 P0）。
• 每个加工至少一条输入流和至少一条输出流。只有入没有出是“数据黑洞”，只有出没有入是“数据奇迹”，都是硬性错误。
• 更深层子图用父编号加点号：P1.1、P1.2，体现逐层分解。

数据存储

• 数据的静态存放处，本身不加工数据。
• 开口矩形三条边、右边不封口；左侧小格写 D 编号，右侧写名称。两条平行线是简化画法，左右都不封口。
• 不能画成封闭矩形（会和外部实体混淆），不能画成圆角矩形（会和加工混淆）。
• 数据存储只能与加工相连：箭头指向存储 = 写入；箭头从存储引出 = 读取。
• 数据存储之间不能直连，外部实体与数据存储之间也不能直连。

数据流

• 单向箭头，表示数据在元素之间的流动方向。
• 命名必须是名词或名词短语，描述“流动的是什么”。
• 绝对不能用动词或加工名来命名（“查询”“计算工资”“处理完成”都是错误命名）。
• 每条流必须有起点和终点，且至少一端是加工。合法连接只有：实体↔加工、加工↔加工、加工↔存储、存储↔加工。

三、DFD 的分层体系

DFD 采用自顶向下、逐层分解的画法，每一层都是一张完整的图。

顶层图（上下文图）

• 整个系统画成一个加工（P0，命名为“XX系统”）。
• 只画外部实体和对外数据流。
• 不出现数据存储，不展开内部加工。
• 作用：界定系统边界，明确系统与外界的所有交互。

0层图

• 顶层图中那个系统加工展开后的第一层细图。
• 包含多个主加工（P1、P2、P3……）、数据存储（D1、D2……）、外部实体（与顶层图同一批）和内部数据流。
• 加工编号从1开始，不出现0号加工（0号留给顶层图的系统整体）。

更深层子图

• 0层图中某个加工继续展开，得到1层图、2层图……
• 子图编号用父编号加点号：P1.1、P1.2。
• 考试中通常只考顶层图和0层图，更深层偶尔以“判断某加工能否继续分解”的形式出现。

分层关系一句话

顶层图只有1个加工，0层图把系统拆成几大块，更深层把某一块再拆细。每层都是一张完整的图，不是把上一层的图改一改。

四、数据平衡三原则（核心考点）

原则一：顶层图与0层图平衡

• 顶层图中系统与外部实体之间的每一条输入流和输出流，在0层图中都必须原样出现（名称一致、方向一致、连接的外部实体一致）。
• 0层图不能多出顶层图没有的对外数据流，也不能缺少顶层图已有的对外数据流。
• 0层图内部的加工间数据流、加工与存储间的数据流，不需要在顶层图中出现，不影响平衡。

原则二：父图与子图平衡

• 父图中某个加工的输入流和输出流，必须与它展开后的子图的输入流和输出流完全一致。
• 子图不能多出父图中没有的跨边界数据流，也不能缺少父图中已有的跨边界数据流。
• 平衡只看跨边界的数据流，子图内部加工之间的流不需要与父图对应。

原则三：加工自身平衡

• 每个加工必须既有输入数据流，又有输出数据流。
• 只有入没有出 = 数据黑洞；只有出没有入 = 数据奇迹。两者都是硬性错误。

平衡口诀

顶层对外几条流，0层必须条条有；名称方向不能变，内部怎么拆随便。父图加工的入出，子图边界不能丢；每个加工有进有出，黑洞奇迹都没有。

父图与子图通俗理解

• 父图是较粗的那层图，某个加工还没有展开。
• 子图是把父图中某一个加工单独展开后得到的细图。
• 这个被展开的加工，就是父图和子图之间的“接口”。
• 举例：0层图中有加工“2.统计成绩”，把它展开得到1层图（2.1读取成绩、2.2计算平均分、2.3生成统计表）。0层图是父图，1层图是子图，平衡要求“2.统计成绩”的对外输入输出与1层图整体的对外输入输出一致。

五、命名规则（高频扣分点）

数据流命名是最高频扣分点。看到数据流名称是动词或加工名，基本可以判定为错误。

六、连线规则与三大禁令

合法连接（只有这五种）

• 外部实体 → 加工
• 加工 → 外部实体
• 加工 → 加工
• 加工 → 数据存储（写入）
• 数据存储 → 加工（读取）

三大禁令

1. 数据存储之间不能直连。
2. 外部实体之间不能直连。
3. 外部实体与数据存储之间不能直连。

所有连接都必须经过加工中转。违反禁令是下午题改错的高频考点。

七、考试题型与答题方法

题型一：补充外部实体或数据存储名称

问法：“指出顶层图中E1、E2分别是什么”“0层图中D1～D4分别是什么”。

方法：

• 外部实体：读题干，找系统边界之外的“人/部门/外部系统”，用题干原词。
• 数据存储：找题干中带“文件、表、库、清单、档案”的名词。

题型二：补充缺失的数据流

问法：“0层图中某加工缺少一条输入数据流，请指出名称、起点和终点”。

方法：

1. 先对比顶层图与0层图，找不平衡的对外流。
2. 逐句读题干，找“提到要读某存储但图上没有入线”或“提到要输出给某实体但图上没有出线”的加工。
3. 检查每个加工是否只有入没有出、或只有出没有入。
4. 答案格式：在加工Y与存储Z之间添加数据流“XX信息”，方向要明确。

关键：数据流的起点或终点必须有一个是加工。

题型三：改错

问法：“0层图中哪条数据流方向画错了”“找出图中的错误”。

方法：按“形状→命名→连线→平衡”四步检查：

• 形状对不对（实体矩形、加工圆角、存储开口）。
• 命名对不对（数据流是否用动词、加工是否只有动词）。
• 连线是否违反三大禁令。
• 加工是否有进有出，父子是否平衡。

题型四：判断某加工能否继续分解

方法：看该加工是否足够简单、是否只有一个明确功能。如果加工内部还有多个子功能或判断逻辑，就可以继续分解；如果已经是原子操作，就不必再拆。

答题规范

• 补充数据流时用题干原词，不要自己发明口语化名称。
• 答案写成“在XX与XX之间添加数据流‘XX’”，起点终点方向明确。
• 数据流名称写名词短语，不写动词。
• 加工名称写动词+名词。

八、高频易错点汇总

1. 数据流用动词或加工名命名（如“计算工资”“处理完成”）→ 必须用名词短语。
2. 数据存储画成封闭矩形 → 与外部实体混淆。
3. 数据存储画成圆角矩形 → 与加工混淆。
4. 加工只有入没有出，或只有出没有入 → 数据黑洞/数据奇迹。
5. 父图子图不平衡：子图多出或缺少数据流，或名称方向不一致。
6. 外部实体与数据存储直连 → 必须经过加工。
7. 数据存储之间直连 → 必须经过加工。
8. 外部实体之间直连 → 必须经过加工。
9. 顶层图出现数据存储 → 顶层图只有加工、实体和数据流。
10. 加工名只写一个动词（如“校验”）→ 必须写清校验什么。
11. 数据流没有起点或终点，或两端都不是加工。
12. 补充数据流时自己发明名称，不用题干原词。

九、DFD 答题检查清单

答完DFD题，按以下顺序自查：

第一步：形状

• 外部实体是封闭矩形？
• 加工是圆角矩形或圆形？
• 数据存储是开口矩形或两条平行线（不是封闭矩形、不是圆角矩形）？
• 数据流是带箭头的单向直线？

第二步：命名

• 数据流是名词短语（不是动词、不是加工名）？
• 加工是“动词+名词”（不是只有动词）？
• 数据存储是名词（不是动作）？

第三步：连线

• 存储没有直连存储？
• 实体没有直连实体？
• 实体没有直连存储？
• 每条数据流至少一端是加工？
• 每个加工有进有出？

第四步：平衡

• 顶层图与0层图的对外流名称、方向、数量一致？
• 父图加工的入出流与子图边界流一致？
• 没有数据黑洞或数据奇迹？

十、DFD 背诵清单（直接背）

1. 四个元素：外部实体（矩形）、加工（圆角矩形/圆）、数据存储（开口矩形/平行线）、数据流（带箭头直线）。
2. 命名规则：实体名词、加工动宾、存储名词、数据流名词短语（不能用动词）。
3. 加工约束：必须有进有出，不能是黑洞或奇迹。
4. 存储约束：只能连加工，不能连存储或实体。
5. 实体约束：不能直连实体，不能直连存储，必须经过加工。
6. 顶层图：1个加工（P0），只有实体和数据流，无数据存储。
7. 0层图：多个加工（P1起），可出现数据存储，外部实体与顶层图相同。
8. 平衡三原则：顶层与0层平衡、父图与子图平衡、加工自身平衡。
9. 父图子图：父图是粗图，子图是父图中某一个加工展开后的细图；平衡要求该加工的对外接口展开前后不变。
10. 平衡口诀：顶层对外几条流，0层必须条条有；名称方向不能变，内部怎么拆随便。
11. 答题格式：在XX与XX之间添加数据流“XX”，起点终点明确，用题干原词。
12. 三大禁令：存储不直连存储、实体不直连实体、实体不直连存储。

十一、DFD 速记口诀

实体矩形在边界，加工圆角带编号；
存储开口只连工，数据箭头名词报。
加工有进必有出，实体存储不直交；
顶层一个对外流，0层条条不能少。
父图子图看边界，名称方向要对牢；
数据流名用名词，动词加工全不要。

把以上内容按“符号→分层→平衡→命名→连线→题型→易错点”的顺序过一遍，再拿历年真题的DFD题练手，重点练“找缺失数据流”和“改错”，这两类问法占分最重。

一、计算机组成与体系结构（1—65）

1. CPU由运算器、控制器、寄存器组和内部总线组成。真题常问“CPU核心部件不包括什么”，存储器不属于CPU核心部件。

2. 运算器核心部件：ALU（算术逻辑单元）、AC（累加器）、DR（数据缓冲寄存器）、PSW（状态条件寄存器） 。

3. 控制器核心部件：PC（程序计数器）、IR（指令寄存器）、指令译码器、时序部件。

4. PC存下一条指令地址，IR存当前指令。2024—2025反复考“PC存当前指令”为错误选项。

5. IR对用户完全透明，用户程序不能直接访问；PC用户可见（可编程访问）。透明性辨析是常考点。

6. 补码的作用：将减法转化为加法，简化运算器设计。2024下半年考过“求补码真值”。

7. 已知X的补码，求−X的补码：连同符号位一起按位取反，末位加1。2025下半年直接考查。

8. 移码：只把补码的符号位取反，其余位不变。常用于浮点数的阶码。

9. 正数的原码、反码、补码三者相同；负数的反码是原码数值位按位取反（符号位不变），补码是反码末位加1。

10. 机器字长为n时，补码表示范围：−2ⁿ⁻¹ 到 2ⁿ⁻¹−1；原码和反码范围：−(2ⁿ⁻¹−1) 到 2ⁿ⁻¹−1。

11. 浮点数：阶码决定范围，尾数决定精度。阶码越长范围越大，尾数越长精度越高。

12. 浮点数运算步骤：对阶→尾数运算→规格化→舍入→溢出判断。

13. 海明校验码：可检错也可纠错，校验位公式 2^r ≥ r + m + 1（m数据位，r校验位）。连续多年考查。

14. 奇偶校验：只能检错，不能纠错。

15. CRC循环冗余校验：可检错，不可纠错，用模2除法计算。

16. 流水线周期：等于各段中最慢的那一段时间。2025下半年给出取指2ns、分析2ns、执行1ns，周期为2ns。

17. 流水线执行时间：单条指令完整时间 +（指令数n−1）× 流水线周期。注意第1条走完全部工段。

18. 流水线吞吐率 = 1 / 流水线周期（指令不重叠时），或按“指令数 / 总时间”计算。

19. 流水线加速比 = 不使用流水线的时间 / 使用流水线的时间。

20. 寻址方式快慢排序：立即寻址 > 寄存器寻址 > 直接寻址 > 间接寻址。立即最快（操作数在指令中），间接最慢（多次访存）。

21. 立即寻址：操作数直接包含在指令中，无需额外访存。

22. 直接寻址：指令中存放操作数的内存地址，需要访问内存获取数据。

23. 间接寻址：指令中存放的是操作数地址的地址，需要多次访存。

24. 寄存器寻址：操作数存放在CPU寄存器中，寻址开销小。

25. Cache的作用：缓解CPU与主存之间的速度矛盾，依据局部性原理。Cache是除寄存器外最快的存储层次。

26. Cache命中率 = 命中次数 / 总访问次数。命中率计算题在2022—2025年均出现。

27. 局部性原理：包括时间局部性（刚用过的数据可能再用）和空间局部性（相邻数据可能被用）。Cache设计的理论基础。

28. 存储访问速度排序：通用寄存器 > Cache > 内存RAM > 硬盘。越靠近CPU，速度越快、容量越小、成本越高。

29. 主存容量计算：容量 = 存储单元数 × 每单元位数。地址线n根，寻址范围 = 2ⁿ 个存储单元。

30. 内存地址范围计算技巧：大减小加1。例如B3000H到DABFFH的容量按此方法计算。

31. 串联系统可靠度 = 各部件可靠度相乘。

32. 并联系统可靠度 = 1 − 各部件失效率相乘（即 1 − (1−R)ⁿ）。并联易错点：不是直接乘可靠度。

33. 总线分类：数据总线双向，地址总线单向（CPU发出地址），控制总线双向。

34. 数据总线宽度决定CPU与内存之间一次能传输的数据位数；地址总线宽度决定寻址范围。

35. RISC特点：指令少、定长、寄存器多、流水线友好、多数指令在一个周期内完成。2022下半年考过RISC特点。

36. CISC特点：指令多、变长、寻址方式多、复杂指令需多个周期。

37. I/O方式效率排序：DMA > 中断 > 程序查询。程序查询CPU全程等待，利用率最低；DMA硬件直接搬数据，CPU几乎不参与。

38. 程序查询方式：CPU需全程等待，无法与CPU并行工作，适用于低速外设。

39. 中断方式：外设就绪后主动发中断信号，CPU无需轮询等待，可与CPU并行工作。

40. DMA方式：无需CPU干预，直接完成主存与外设数据交换，传输效率最高，适用于硬盘、显卡等高速设备。

41. 中断响应时，CPU保存程序计数器（PC） 和程序状态字（PSW），然后转中断服务程序。

42. 中断向量：存放中断服务程序入口地址。中断向量表在内存固定区域。

43. DMA与中断的区别：DMA不需要CPU逐字节介入，中断需要CPU执行中断服务程序。

44. 虚拟存储：解决主存容量不足的问题，由页式/段式/段页式管理。逻辑地址 = 页号 + 页内偏移。

45. 地址总线宽度与寻址范围：地址线n根，可寻址 2ⁿ 个单元。

46. 字节 = 8 bit；字 = 机器字长。主存编址分“按字节编址”和“按字编址”。

47. 最小数据单位是bit，最小存储单位是byte。

48. 进制表示：D十进制、B二进制、O八进制、H十六进制。

49. 定点整数补码可表示 2ⁿ 个数（比原码多一个负数）。

50. 冯·诺依曼体系结构的核心思想：存储程序，指令和数据以同等地位存放在存储器中。

51. 指令的组成：操作码 + 地址码。操作码指明做什么，地址码指明操作数在哪里。

52. 指令执行三步骤：取指—分析—执行。流水线计算的基础框架。

53. CPU与主存之间的速度矛盾由Cache缓解；主存与辅存之间的容量矛盾由虚拟存储缓解。

54. Spooling技术：将独占设备改造为虚拟共享设备，解决CPU与设备速度不匹配。

55. 总线结构：单总线、双总线、三总线。三总线包括数据总线、地址总线、控制总线。

56. 磁盘容量计算：容量 = 磁头数 × 柱面数 × 每道扇区数 × 每扇区字节数。

57. 磁盘存取时间 = 寻道时间 + 旋转延迟 + 传输时间。寻道时间通常最长。

58. RAID：RAID 0条带化无冗余；RAID 1镜像；RAID 5分布式奇偶校验。

59. 编码：ASCII码7位表示128个字符；汉字国标码/区位码；机内码用于计算机内部存储。

60. 逻辑运算：与（AND）、或（OR）、非（NOT）、异或（XOR）。异或：相同为0，不同为1。

61. 码制转换：原码→反码→补码→移码的转换链条必须熟练。

62. 零的表示：原码和反码中零有正零和负零两种；补码和移码中零唯一。

63. 浮点数溢出判断：阶码溢出才是真正的溢出，尾数溢出可通过规格化纠正。

64. CPU中的寄存器：用户可见的有PC、通用寄存器；用户不可见（透明）的有IR、MAR、MDR。

65. 多核CPU：每个核心有独立的运算器和控制器，共享Cache和内存。

二、操作系统（66—130）

66. 进程三态转换：运行 → 阻塞（等待I/O或事件）；阻塞 → 就绪（事件完成）；就绪 → 运行（被调度）。

67. 进程不能从阻塞直接转为运行，必须先转为就绪再被调度。

68. 进程与线程的资源共享：同一进程内线程共享代码段、全局变量、打开文件；但每个线程有独立栈和寄存器。

69. 线程共享内容：进程代码段、公有数据、打开的文件描述符、信号处理器、当前目录、用户ID与组ID。

70. 线程独有内容：线程ID、独立寄存器组、线程堆栈（栈指针）、错误返回码、信号屏蔽码。

71. 线程是CPU调度的基本单位，进程是资源分配的基本单位。

72. PV操作方向：前趋图中，箭线起点是V（前驱完成通知），终点是P（后继开始前等待）。互斥信号量初值1，同步信号量初值通常0。

73. P操作：P(S)使S = S − 1；若S < 0，进程阻塞。

74. V操作：V(S)使S = S + 1；若S ≤ 0，唤醒一个等待进程。

75. 死锁四个必要条件：互斥、请求与保持、不可剥夺、循环等待。四个同时满足才可能死锁。

76. 不死锁判定公式：m × (w − 1) + 1 ≤ n 时不可能死锁（m进程数，w每进程最大需求，n资源总数）。

77. 银行家算法：用于避免死锁，判断系统是否存在安全序列。

78. 死锁预防：破坏四个必要条件之一；死锁避免：银行家算法动态判断。概念辨析是2025年考点。

79. 页式存储地址转换：逻辑地址 = 页号 + 页内偏移；页表把页号映射为物理块号。

80. 页面淘汰原则：被修改过的脏页要写回磁盘，未修改的直接丢弃。

81. FIFO页面置换可能产生Belady异常（物理块增多，缺页率反而上升）；LRU不会。

82. LRU（最近最少使用） ：淘汰最长时间未被访问的页面。

83. OPT（最优置换） ：淘汰未来最长时间内不被访问的页面，理论最优但不可实现。

84. 页表的作用：记录页号到物理块号的映射，页表项还包含有效位、修改位、访问位等。

85. 快表（TLB） ：存放最近使用的页表项，加速地址转换，依据局部性原理。

86. 段页式存储：先分段，段内再分页。地址 = 段号 + 页号 + 页内偏移。

87. 内存碎片：固定分区产生内部碎片；动态分区产生外部碎片；页式有内部碎片无外部碎片；段式有外部碎片。

88. 文件物理结构：连续结构存取快但产生碎片；链接结构无碎片但只能顺序访问；索引结构支持随机访问，索引表占空间。

89. 绝对路径：从根目录开始；相对路径：从当前工作目录开始。

90. 树形目录结构：支持文件重名、便于分类管理，绝对路径和相对路径结合使用。

91. 索引文件：通过索引表访问文件块，支持随机存取。

92. 位示图：用二进制位表示磁盘块占用情况，常考字号、位号计算。

93. 磁盘调度算法：SSTF（最短寻道时间优先） 可能饥饿；SCAN（电梯算法） 兼顾方向；FCFS 最简单。

94. 进程调度算法：FCFS简单但平均等待时间长；短作业优先平均等待最短但可能饥饿；时间片轮转公平但上下文切换开销大。

95. 临界区：一次只允许一个进程进入的代码段。PV操作实现互斥访问临界区。

96. 信号量：互斥信号量用于互斥，初值1；同步信号量用于同步，初值视条件而定（常为0）。

97. 进程同步的临界资源：打印机、共享变量等一次只允许一个进程使用的资源。

98. 线程的实现方式：用户级线程（内核不可见，切换快）和内核级线程（内核管理，可多核并行）。

99. 死锁检测：通过资源分配图判断是否存在环路；有环不一定死锁（同类资源多个时）。

100. 虚拟存储的容量：由地址空间决定（逻辑地址位数），不是由内存和外存容量简单相加决定。

101. I/O软件层次：用户层I/O → 设备独立性软件 → 设备驱动程序 → 中断处理程序 → 硬件。

102. Spooling系统的组成：输入井、输出井、输入缓冲区、输出缓冲区、输入进程、输出进程。

103. 操作系统的四大功能：进程管理、存储管理、文件管理、设备管理。

104. 操作系统的特征：并发、共享、虚拟、异步。

105. 批处理系统：吞吐量大，但交互性差；分时系统：交互性好，响应时间短；实时系统：对响应时间有严格限制。

106. PCB（进程控制块） ：进程存在的唯一标志，包含进程标识符、状态、优先级、资源清单等。

107. 进程创建：分配PCB、分配资源、调入内存、转入就绪态。

108. 进程终止：释放资源、回收PCB。

109. 进程切换：保存当前进程上下文，恢复新进程上下文，开销较大。

110. 线程切换：同进程内线程切换只需保存/恢复寄存器和栈指针，开销小于进程切换。

111. 作业调度：从后备队列选择作业调入内存；进程调度：从就绪队列选择进程分配CPU。

112. 多级反馈队列调度：兼顾不同类型进程，短作业优先、长作业不饥饿。

113. 优先级调度：静态优先级和动态优先级；可能产生优先级反转问题。

114. 优先级反转：低优先级进程持有高优先级进程需要的资源，导致高优先级进程被阻塞。

115. 管程：封装共享资源和操作，简化同步编程，避免PV操作的分散错误。

116. 生产者—消费者问题：用PV操作实现同步与互斥，缓冲区是临界资源。

117. 读者—写者问题：允许多个读者同时读，写者与任何人互斥。

118. 哲学家进餐问题：死锁的经典场景，通过限制同时拿筷子的哲学家数量来预防。

119. 文件逻辑结构：有结构文件（记录式）和无结构文件（流式）。

120. 文件目录：FCB（文件控制块）存放文件名、物理位置、大小、权限等。

121. 文件共享：硬链接（多个目录项指向同一inode）和软链接（符号链接，指向路径名）。

122. 文件保护：访问控制矩阵、访问控制表（ACL）、能力表。

123. 磁盘空间管理：空闲表法、空闲链表法、位示图法、成组链接法。

124. 成组链接法：UNIX常用，将空闲块分组管理，节省空间。

125. 设备管理：独占设备、共享设备、虚拟设备。

126. 设备驱动程序：与硬件直接交互，屏蔽硬件差异。

127. 中断处理程序：处理I/O完成中断，唤醒等待进程。

128. 缓冲技术：单缓冲、双缓冲、多缓冲，缓解CPU与I/O速度不匹配。

129. 操作系统启动过程：BIOS自检 → 引导程序 → 加载内核 → 初始化 → 启动用户态。

130. 微内核结构：内核只保留最基本功能，其他服务在用户态运行，提高可靠性和可扩展性。

三、数据结构与算法（131—215）

131. 栈的特性：后进先出（LIFO） 。2025年直接考“栈遵循先进先出”为错误选项。

132. 队列的特性：先进先出（FIFO） 。

133. 循环队列解决顺序队列的假溢出。判满：(rear + 1) % maxSize == front（牺牲一个单元）。

134. 链表操作：删除最后一个结点需要遍历链表；删除/插入头结点只需操作头指针。

135. 顺序表：随机访问O(1)，插入/删除平均O(n)。

136. 单链表：不支持随机访问，查找O(n)，插入/删除已知前驱时O(1)。

137. 双向链表：可双向遍历，插入/删除更方便。

138. 栈的应用：表达式求值、括号匹配、递归实现、函数调用。

139. 队列的应用：BFS、缓冲区、任务调度。

140. 二叉树遍历：前序“根左右”，中序“左根右”，后序“左右根”。

141. 二叉树还原：已知中序 + 前序或中序 + 后序可唯一还原；已知前序 + 后序不能唯一确定。

142. 完全二叉树：结点编号与满二叉树对应，叶子只出现在最后两层。

143. 满二叉树结点数：深度为k的满二叉树有 2^k − 1 个结点。

144. 二叉树性质：第i层最多 2^(i−1) 个结点；深度为k最多 2^k − 1 个结点。

145. 哈夫曼树：权值小的优先合并，带权路径长度最小。频率高的字符编码短。

146. 哈夫曼编码是前缀编码，任一编码不是另一编码的前缀。

147. 二叉排序树（BST） ：左子树 < 根 < 右子树；中序遍历得到有序序列。

148. 平衡二叉树（AVL） ：左右子树高度差绝对值 ≤ 1。插入/删除可能需要旋转（LL、RR、LR、RL）。

149. B树：多路平衡查找树，每个结点既存关键字也存数据。

150. B+树：只有叶子结点存数据，非叶子只存索引，叶子间用指针连成链表，范围查询更快。数据库索引常用。

151. 图的存储：邻接矩阵适合稠密图，邻接表适合稀疏图。

152. 邻接矩阵：空间O(n²)，判断两点是否相邻O(1)；邻接表：空间O(n+e)，遍历邻接点高效。

153. 图的遍历：DFS用栈（递归），BFS用队列。

154. 拓扑排序：用于AOV网，每次输出入度为0的顶点；能输出全部顶点则无环。

155. 关键路径：AOE网中最长路径，关键活动时间裕量为0。

156. 最小生成树：Prim适合稠密图，Kruskal适合稀疏图。

157. 最短路径：Dijkstra单源、不能负权；Floyd多源、可负权但不能负环。

158. 排序平均复杂度O(n log n) ：快排、归并、堆排（“快归堆”）。

159. 排序平均复杂度O(n²) ：冒泡、插入、选择（“冒插选”）。

160. 不稳定排序：快排、希尔、选择、堆排（“快希选堆”）。

161. 稳定排序：冒泡、插入、归并、基数。

162. 快速排序最坏情况：基本有序时退化为 O(n²) 。

163. 归并排序空间复杂度：O(n) ，需要辅助数组。

164. 堆排序建堆时间：O(n) ；每次调整 O(log n) ，总时间 O(n log n) 。

165. 冒泡排序：稳定，最好O(n)（已有序），最坏O(n²)。

166. 插入排序：稳定，基本有序时效率高。

167. 选择排序：不稳定，无论初始顺序如何都是O(n²)。

168. 希尔排序：不稳定，是插入排序的改进，按增量分组。

169. 基数排序：稳定，非比较排序，时间复杂度O(d(n+r))。

170. 二分查找：必须有序，时间复杂度 O(log n) 。

171. 二分查找最多比较次数：⌈log₂(n+1)⌉。

172. 哈希冲突处理：开放定址法（线性探测、二次探测）、链地址法。链地址法不产生聚集。

173. 哈希表查找：理想情况O(1)，冲突严重时退化。

174. 时间复杂度增长顺序：O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(n³) < O(2ⁿ) < O(n!) 。

175. 分治法：将问题分解为相互独立的子问题，递归求解后合并（归并排序、二分查找）。

176. 动态规划：子问题重叠，用表格保存已解子问题，避免重复计算。典型：0-1背包、最长公共子序列。

177. 贪心法：每步选当前最优，不回溯，不保证全局最优。典型：活动安排、哈夫曼编码、Dijkstra。

178. 回溯法：递归尝试 + 剪枝 + 恢复现场。典型：N皇后、排列组合。

179. 递归与栈：递归调用使用系统栈保存返回地址和局部变量。

180. 字符串：朴素匹配最坏O(mn)；KMP利用next数组达到O(m+n)。

181. 数组与矩阵：二维数组按行存储和按列存储的地址计算公式不同。

182. 特殊矩阵压缩：对称矩阵、三角矩阵、对角矩阵的压缩存储。

183. 稀疏矩阵压缩：三元组表（行、列、值）或十字链表。

184. 广义表：表头（第一个元素）、表尾（除表头外的剩余元素）。长度和深度的计算。

185. 树转二叉树：左孩子右兄弟。

186. 森林转二叉树：每棵树转二叉树后，根结点依次相连。

187. 顺序查找：O(n)，不要求有序。

188. 分块查找：块间有序、块内无序，平均性能介于顺序和二分之间。

189. 动态查找表：二叉排序树、AVL树、B树、B+树、哈希表。

190. 静态查找表：顺序查找、二分查找、分块查找。

191. 算法效率度量：时间复杂度和空间复杂度，关注最坏情况。

192. 递归算法：必须有递归出口，否则无限递归。

193. 迭代与递归：迭代通常效率更高（无函数调用开销），递归代码更简洁。

194. 稳定排序的选择：需要保留相等元素原始顺序时，选择冒泡、插入、归并、基数。

195. 基本有序时的排序选择：插入排序或冒泡排序效率最高。

196. 空间紧张时的排序选择：堆排序（原地排序，空间O(1)）。

197. 求Top K问题：用堆排序或快速选择，不需要完全排序。

198. 外部排序：数据量大于内存时使用，多路归并。

199. 贪心法与动态规划的区别：贪心不回溯、不保证最优；动态规划保存子问题解、保证最优。

200. 分治法与动态规划的区别：分治子问题独立；动态规划子问题重叠。

201. 回溯法的剪枝：提前判断当前路径不可能产生解，减少搜索空间。

202. N皇后问题：n=4时解为2。2025下半年算法题直接考查。

203. 背包问题：0-1背包用动态规划；部分背包用贪心法。

204. 最长公共子序列（LCS） ：动态规划，时间复杂度O(mn)。

205. Dijkstra算法：贪心策略，不能处理负权边。

206. Floyd算法：动态规划思想，三重循环，O(n³)。

207. Prim算法：从顶点出发，每次选连接已选集合和未选集合的最小边。

208. Kruskal算法：按边权排序，用并查集判断是否成环。

209. 拓扑排序的应用：判断有向图是否有环、确定任务执行顺序。

210. 关键路径的应用：确定工程最短工期，关键活动不能延误。

211. AOV网：顶点表示活动，边表示活动之间的优先关系。

212. AOE网：边表示活动，顶点表示事件，边权表示活动持续时间。

213. 事件的最早发生时间：从源点正向计算，取最大值。

214. 事件的最迟发生时间：从汇点反向计算，取最小值。

215. 活动的时间裕量 = 最迟开始时间 − 最早开始时间。裕量为0的活动是关键活动。

四、程序设计语言基础（216—265）

216. 编译过程顺序：词法分析 → 语法分析 → 语义分析 → 中间代码生成 → 优化 → 目标代码生成。

217. 词法分析：识别单词（标识符、关键字、常数），依据正规式/有限自动机。

218. 语法分析：判断句子结构是否符合文法，括号不匹配在此阶段发现。

219. 语义分析：检查语义合法性（变量未声明、类型不匹配）。

220. 中间代码：与具体机器无关，便于优化和移植。常见形式：四元式、三元式、逆波兰式。

221. 目标代码生成：生成汇编或机器码，与具体硬件相关。

222. 编译型语言：先翻译后执行，效率高但可移植性差。C、C++是编译型。

223. 解释型语言：边翻译边执行，可移植性好但效率低。Python、JavaScript是解释型。

224. Python特点：跨平台、开源、解释型、面向对象、动态编程。不是编译型。

225. 有限自动机DFA：每个状态对同一输入只有唯一后继；NFA可有多个后继。

226. 正规式与有限自动机：两者等价，都用于描述词法规则。

227. 文法：上下文无关文法用于描述程序设计语言的语法结构。

228. 语法树：根是开始符号，叶子是终结符，内部结点是非终结符。

229. 传值调用：形参是实参的副本，修改形参不影响实参。

230. 传址/引用调用：形参是实参的地址或别名，修改形参会改变实参。

231. 后缀表达式（逆波兰式） ：操作数在前，运算符在后；用栈求值。

232. 中缀转后缀：按运算符优先级和括号规则转换，操作数顺序不变。

233. 程序设计语言的基本成分：数据、运算、控制、传输。控制包括顺序、选择、循环。

234. 标识符作用域：局部变量、全局变量、静态局部变量的生命周期和可见性不同。

235. 静态变量：生命周期贯穿程序运行，但作用域限于定义它的函数/文件。

236. 动态语义与静态语义：静态语义在编译期检查（类型匹配）；动态语义在运行期体现（数组越界）。

237. 编译优化：局部优化、循环优化、全局优化。优化不改变程序语义。

238. 词法分析的工具：LEX；语法分析的工具：YACC。

239. 上下文无关文法：用产生式描述语法，四元组（非终结符、终结符、产生式、开始符号）。

240. 正规式：描述词法规则，与有限自动机等价。

241. 表达式求值：中缀、前缀、后缀三种形式，后缀最适合计算机求值。

242. 函数调用的参数传递：传值、传地址、传名。传名调用在每次使用时重新求值实参。

243. 递归函数的实现：依赖系统栈保存返回地址和局部变量。

244. 变量的存储分配：静态分配（编译期确定）和动态分配（运行期确定）。

245. 堆和栈：栈由编译器自动管理，存放局部变量和返回地址；堆由程序员手动管理（如malloc/new）。

246. 内存泄漏：动态分配的内存未释放，导致可用内存逐渐减少。

247. 编译错误的类型：词法错误（非法字符）、语法错误（结构错误）、语义错误（类型不匹配）。

248. 解释器的组成：词法分析、语法分析、语义分析、执行。

249. 编译器与解释器的区别：编译器生成目标代码，解释器直接执行源程序或中间代码。

250. 程序设计语言的分类：命令式、函数式、逻辑式、面向对象。Prolog是逻辑式语言。

251. C语言的特点：编译型、静态类型、接近硬件、可移植性较好。

252. 面向对象语言的特征：封装、继承、多态。

253. 动态绑定：运行时根据对象实际类型决定调用哪个方法（多态的实现机制）。

254. 静态绑定：编译时确定方法调用（如重载）。

255. 重载（Overload） ：同一作用域内方法名相同、参数列表不同。

256. 重写（Override） ：子类重新定义父类的方法，方法签名相同。

257. 值传递与引用传递的输出判断：常考程序运行后变量的值，注意形参是否改变实参。

258. 变量的初始化：局部变量未初始化时值不确定；全局变量默认初始化为0。

259. 短路求值：逻辑与/或运算可能不计算右侧表达式。

260. 运算符优先级：括号 > 单目 > 算术 > 关系 > 逻辑 > 赋值。

261. 类型转换：隐式转换和显式转换（强制类型转换），注意精度丢失。

262. 数组名：在表达式中通常退化为指向首元素的指针。

263. 指针与引用：指针可以为空、可以重新赋值；引用必须初始化且不能更换绑定。

264. 函数指针：指向函数的指针，可用于回调机制。

265. 编译预处理：宏定义、文件包含、条件编译，在编译之前处理。

五、软件工程（266—350）

266. 瀑布模型：阶段严格顺序、文档驱动，不够灵活，难以适应需求变化。适合需求明确的项目。

267. 瀑布模型的五个阶段：需求分析、设计、编码、测试、维护。每阶段有评审和文档控制。

268. V模型：瀑布模型的变体，开发阶段与测试阶段一一对应（需求↔验收测试，设计↔集成测试）。

269. 原型模型：快速构建原型验证需求，适合需求不明确的项目。

270. 螺旋模型：强调风险分析，适合大型复杂项目。

271. 增量模型：分批交付，每个增量是一个可运行的部分。第一个增量是核心产品。

272. 敏捷开发：迭代、快速响应变化；每日站会、结对编程（XP） 是典型实践。

273. 极限编程（XP）的价值观：沟通、简单、反馈、勇气。

274. Scrum：迭代周期称为Sprint，角色有Product Owner、Scrum Master、开发团队。

275. 喷泉模型：面向对象开发，阶段无明显边界、迭代重叠。

276. 统一过程（RUP） ：四个阶段——起始、精化、构建、移交。

277. CMM 5级：初始级 → 可重复级 → 已定义级 → 已管理级 → 优化级。

278. CMM初始级：成功依赖个人英雄主义，过程混乱。

279. CMM可重复级：建立基本项目管理过程，跟踪费用、进度、功能。

280. CMM已定义级：过程文档化、标准化。

281. CMM已管理级：对过程和产品质量进行定量管理。

282. CMM优化级：持续过程改进，定量分析。

283. CMMI两种表示法：阶段式模型和连续式模型。

284. 内聚从高到低：功能 > 顺序 > 通信 > 过程 > 时间 > 逻辑 > 偶然。

285. 功能内聚：模块内所有元素共同完成一个单一功能，内聚最高。

286. 偶然内聚：模块内元素之间没有实质联系，内聚最低。

287. 逻辑内聚：模块内执行逻辑上相似的功能，由参数决定执行哪一个。

288. 时间内聚：模块内任务必须在同一时间段内执行。

289. 过程内聚：模块内任务必须按特定次序执行。

290. 通信内聚：模块内所有元素操作同一数据结构或使用同一输入/输出。

291. 顺序内聚：模块内一个元素的输出是另一个元素的输入。

292. 耦合从低到高：非直接 > 数据 > 标记 > 控制 > 外部 > 公共 > 内容。

293. 内容耦合最高：一个模块直接访问另一个模块的内部数据或代码。

294. 数据耦合：模块间只传递数据参数，耦合最低（除非直接耦合外）。

295. 设计原则：高内聚、低耦合。

296. 信息隐蔽：模块内部实现细节对使用者隐藏，提高可修改性。

297. McCabe环路复杂度：边 − 节点 + 2，或判定节点数 + 1。

298. 黑盒测试：等价类划分、边界值分析，不关心内部逻辑。

299. 白盒测试：逻辑覆盖（语句、判定、条件、路径）。路径覆盖覆盖程度最高。

300. 语句覆盖：每条语句至少执行一次，最弱的逻辑覆盖。

301. 判定覆盖：每个判断的真假分支至少各执行一次。

302. 条件覆盖：每个判断中每个条件的真假至少各出现一次。

303. 路径覆盖：所有可能路径至少执行一次，覆盖最强。

304. 测试顺序：单元测试 → 集成测试 → 系统测试 → 验收测试。

305. 单元测试：针对单个模块，常用白盒测试。

306. 集成测试策略：一次性集成、自顶向下、自底向上、三明治集成。

307. 自顶向下集成：需要桩模块（stub）模拟下层模块。

308. 自底向上集成：需要驱动模块（driver）模拟上层模块。

309. 系统测试：整个系统与环境集成后测试，黑盒为主。

310. 验收测试：用户参与，确认系统满足需求。

311. 回归测试：修改代码后重新测试，确保未引入新错误。

312. 软件维护类型：纠错性（修bug）、适应性（环境变化）、完善性（加功能/改善性能）、预防性（提高可维护性）。

313. 完善性维护：占比通常最大，为了增加功能或改善性能。

314. 纠错性维护：修复运行中发现的错误。

315. 适应性维护：适应硬件、软件环境的变化。

316. 预防性维护：为了提高未来可维护性而修改软件。

317. 软件危机表现：费用和进度失控、质量低下、难以维护、生产率低下。

318. SRS（需求规格说明书）特性：完整性、一致性、可验证性、可修改性、可追踪性。

319. 需求分析阶段的任务：确定系统“做什么”，输出需求规格说明书。

320. 概要设计 vs 详细设计：概要设计定体系结构和模块划分；详细设计定模块内部算法和数据结构。

321. 结构化分析方法：数据流图（DFD）、数据字典、加工说明。核心是自顶向下逐层分解。

322. 结构化设计：模块化、信息隐蔽、模块独立性。信息隐蔽提高可修改性。

323. 模块独立性由内聚和耦合共同决定。

324. 软件质量特性（ISO 9126） ：功能性、可靠性、易用性、效率、可维护性、可移植性。

325. 可移植性设计：核心是屏蔽平台差异；“使用特定环境专用功能”是破坏可移植性的做法。

326. 风险管理：风险识别 → 风险预测 → 风险评估 → 风险控制。

327. 风险暴露 = 风险概率 × 风险影响。

328. PERT图：用于进度管理，边表示任务，节点表示事件，可计算关键路径。

329. Gantt图：横道图，直观展示任务时间，但不能显示任务间依赖关系。

330. 关键路径：PERT图中最长路径，决定项目最短工期。

331. 软件文档：开发文档、管理文档、用户文档。文档是软件产品的一部分。

332. 数据流图（DFD） ：描述数据流动和加工，四种元素——外部实体、加工、数据存储、数据流。

333. 数据字典：对DFD中每个元素的定义，包括数据项、数据结构、数据流、数据存储、加工。

334. 结构化语言：用于描述加工逻辑，包括顺序、选择、循环。

335. 判定表/判定树：描述复杂条件组合下的加工逻辑。

336. 系统总体结构设计：将系统划分为模块，确定模块间调用关系。

337. 模块扇入扇出：扇入指调用该模块的上级模块数；扇出指该模块调用的下级模块数。

338. 深度与宽度：深度指模块调用层次；宽度指同一层模块数。

339. 软件过程：软件生命周期中的一系列活动，包括开发过程、管理过程、支持过程。

340. 软件生命周期：可行性分析、需求分析、设计、编码、测试、维护。

341. 可行性分析：技术可行性、经济可行性、操作可行性、法律可行性。

342. 成本估算：COCOMO模型、Putnam模型、专家判断法。

343. COCOMO模型：基于代码行数估算工作量，分为基本、中间、详细三级。

344. 软件配置管理：版本控制、变更管理、配置审计。

345. 基线：经过评审和批准的配置项，变更需走变更控制流程。

346. 版本控制工具：Git、SVN，管理代码版本和协作开发。

347. 软件复用：代码复用、设计复用、分析复用、测试复用。

348. 逆向工程：从代码恢复设计信息，用于维护和改造遗留系统。

349. 再工程：逆向工程 + 重构 + 正向工程，改造旧系统。

350. 软件质量保证（SQA） ：通过过程审计和产品评审确保质量。

六、面向对象与UML（351—410）

351. 类图关系强弱：依赖 < 关联 < 聚合 < 组合 < 泛化（继承）< 实现。

352. 聚合 vs 组合：聚合空心菱形，整体消失部分还在；组合实心菱形，整体消失部分随之销毁。

353. 菱形位置：聚合/组合的菱形永远在整体一端。

354. 泛化：实线 + 空心三角，三角指向父类。

355. 实现：虚线 + 空心三角，三角指向接口。

356. 依赖：虚线 + 开口箭头，指向被依赖类。方法参数/局部变量中使用，临时关系。

357. 关联：实线，成员变量持有，长期结构关系。

358. 用例关系include：虚线箭头指向被包含用例，表示一定会执行的公共行为。

359. 用例关系extend：虚线箭头指向基础用例，表示有条件才执行的扩展行为。

360. include与extend箭头口诀：“包箭被，扩箭基” ——include指被包含，extend指基础。

361. 参与者：火柴人，画在系统边界之外。“时间”不能作为参与者。

362. 用例名：动词 + 名词，对参与者有可观测的完整结果；不拆内部步骤（“验证密码”不是用例）。

363. UML静态图：类图、对象图、用例图、构件图、部署图。

364. UML动态图：序列图、通信图、状态图、活动图。

365. 通信图：强调对象之间的链和消息，与序列图语义相近。

366. 对象图：某一时刻一组对象及关系的快照。

367. 状态图：描述一个对象在生命周期内的状态变迁。

368. 活动图：描述流程和并行行为，有分叉/汇合。

369. 部署图：实施阶段使用，描述物理节点和构件分布。

370. 序列图：强调消息传递的时间顺序。对象框、生命线（虚线）、激活期（长条）。

371. 序列图消息类型：同步消息（实心三角）、异步消息（空心三角）、返回消息（虚线开口箭头）。

372. 多重度：1恰好一个；0..1零或一个；0..*或*零个或多个；1..*至少一个。

373. 多重度判定：站在每一端看对方，两端都要标。

374. 开闭原则：对扩展开放，对修改关闭。

375. 单一职责原则：一个类只做一种类型的功能，修改原因只有一个。

376. 里氏替换原则：子类可以替换父类而不改变程序正确性。

377. 依赖倒置原则：依赖抽象，不依赖具体实现。

378. 接口隔离原则：使用多个专门接口，而不是一个庞大接口。

379. 迪米特法则：一个对象应尽可能少地了解其他对象（最少知识原则）。

380. 封装：隐藏内部实现细节，只暴露必要接口。

381. 继承：子类获得父类的属性和方法，实现代码复用。

382. 多态：同一接口，不同实现。运行时根据实际对象类型决定调用哪个方法（动态绑定）。

383. 抽象类：不能实例化，可包含抽象方法和具体方法。

384. 接口：只包含抽象方法（Java 8后可有默认方法），类可以实现多个接口。

385. 面向对象分析（OOA） ：识别对象、类、关系，建立分析模型。

386. 面向对象设计（OOD） ：设计类结构、接口、交互，建立设计模型。

387. 面向对象测试：单元测试类，集成测试类间交互，系统测试整体行为。

388. 继承的透明性：子类应能完全替代父类（里氏替换）。

389. 组合优于继承：组合更灵活，避免继承层次过深。

390. UML中的接口：用类框加«interface»构造型表示，或圆形表示。

391. 构件图：描述软件构件及其依赖关系。

392. 包图：将模型元素分组，管理复杂度。

393. UML用例图的作用：描述系统功能需求，参与者与用例的关系。

394. UML类图的作用：描述系统静态结构，类的属性和方法及关系。

395. UML序列图的作用：描述对象间按时间顺序的消息交互。

396. UML状态图的作用：描述对象状态变迁及触发事件。

397. UML活动图的作用：描述业务流程或算法流程，支持并行。

398. UML部署图的作用：描述系统物理部署，节点和构件的分布。

399. 用例之间的泛化：子用例继承父用例的行为，空心三角指向父用例。

400. 参与者之间的泛化：子参与者继承父参与者的用例。

401. 包含关系是必须的，扩展关系是可选的。

402. 类图中的可见性：+公开，-私有，#保护，~包内可见。

403. 抽象操作：斜体表示，子类必须实现。

404. 静态成员：下划线表示，属于类而非实例。

405. 关联类：关联本身也可以有属性，用类表示并连接到关联线上。

406. 限定关联：用限定符缩小多重度范围。

407. 依赖的构造型：«use»、«call»、«create»等。

408. UML中的注释：折角矩形，用虚线连接到被注释元素。

409. UML图的选择：静态结构选类图，交互选序列图/通信图，流程选活动图，状态变迁选状态图。

410. 面向对象方法的优点：可复用、可扩展、可维护，映射问题域自然。

七、数据库系统（411—465）

411. 三级模式：外模式（用户视图）、模式（逻辑结构）、内模式（物理存储）。

412. 两级映像：外模式/模式映像保证逻辑独立性；模式/内模式映像保证物理独立性。

413. E-R转关系模式 1:N：1端主键放入N端作外键。方向不能反。

414. E-R转关系模式 M:N：必须单独建表，主键 = 双方主键组合，双方主键各自也是外键。

415. E-R转关系模式 1:1：任一方主键放入另一方作外键（或两表合并）。

416. 范式 1NF：属性不可再分。

417. 范式 2NF：消除非主属性对码的部分函数依赖。

418. 范式 3NF：消除非主属性对码的传递函数依赖。

419. BCNF：消除主属性对码的部分和传递依赖，比3NF更严格。

420. 函数依赖：X→Y表示X决定Y。候选键是能决定所有属性的最小属性集。

421. 主属性：包含在任一候选键中的属性；非主属性：不包含在任何候选键中的属性。

422. 部分函数依赖：非主属性只依赖联合主键的一部分。

423. 传递函数依赖：A→B，B→C，且B不是候选键，则A→C是传递依赖。

424. 事务ACID：原子性、一致性、隔离性、持久性。

425. 脏读：读到其他事务未提交的数据。避免脏读的隔离级别至少是读已提交（Read Committed） 。

426. 不可重复读：同一事务内两次读同一数据结果不同（其他事务修改并提交了）。

427. 幻读：同一事务内两次查询返回不同行数（其他事务插入/删除了行）。

428. 隔离级别从低到高：读未提交 → 读已提交 → 可重复读 → 串行化。

429. 封锁协议：一级封锁防丢失修改；二级防脏读；三级防不可重复读。

430. 共享锁（S锁） ：读锁，多个事务可同时持有。

431. 排他锁（X锁） ：写锁，独占，与任何锁互斥。

432. 两段锁协议：加锁阶段和解锁阶段，保证可串行化。

433. SQL的WHERE与HAVING：WHERE过滤行（分组前）；HAVING过滤分组后的组。

434. SQL聚合函数：COUNT、SUM、AVG、MAX、MIN。

435. 多表查询：必须写JOIN和连接条件，漏掉连接条件会变成笛卡尔积。

436. 内连接：只返回匹配的行；外连接：返回不匹配的行（左外、右外、全外）。

437. 子查询：嵌套在另一个查询中的查询，可用于IN、EXISTS、比较运算。

438. GROUP BY：按列分组，常与聚合函数配合使用。

439. ORDER BY：排序，ASC升序（默认），DESC降序。

440. 数据库设计六步骤：需求分析 → 概念设计 → 逻辑设计 → 物理设计 → 实施 → 维护和优化。

441. 概念设计：输出E-R图，与具体DBMS无关。

442. 逻辑设计：将E-R图转换为关系模式，进行规范化。

443. 物理设计：确定存储结构、索引、分区等。

444. 关系代数运算：并、差、笛卡尔积、选择、投影、连接。

445. 选择（σ） ：按条件筛选行；投影（π） ：选择列。

446. 自然连接：自动按同名属性等值连接，并去掉重复列。

447. 笛卡尔积：两个关系的所有元组组合，通常需要配合选择条件才有意义。

448. 主键：唯一标识元组，不能为空，不能重复。

449. 外键：引用另一个关系的主键，可以为空，但非空时必须存在。

450. 实体完整性：主键不能为空。

451. 参照完整性：外键必须引用存在的主键值，或为空。

452. 用户定义完整性：业务规则约束（如年龄范围）。

453. 视图：虚表，不存储数据，简化查询和权限控制。

454. 索引：加速查询，但增加插入/删除/更新的开销。

455. 聚集索引：数据物理顺序与索引顺序一致；非聚集索引：不一致。

456. 分布式数据库：数据分布在多个节点，透明性包括位置透明、分片透明、复制透明。

457. 数据仓库：面向主题、集成、相对稳定、反映历史变化，用于分析决策。

458. OLTP vs OLAP：OLTP面向事务处理，OLAP面向分析。

459. 数据挖掘：从大量数据中发现模式，分类、聚类、关联规则。

460. NoSQL：非关系型数据库，适合大数据和高并发，如键值、文档、列族、图数据库。

461. CAP定理：一致性、可用性、分区容错性三者不可兼得。

462. 数据库备份：完全备份、增量备份、差异备份。

463. 数据库恢复：利用日志 undo/redo，将数据库恢复到一致状态。

464. 检查点：减少恢复时需要重做的日志量。

465. 数据库安全：认证、授权（GRANT/REVOKE）、加密、审计。

八、计算机网络与信息安全（466—510）

466. 网络设备层次：Hub物理层，交换机数据链路层，路由器网络层，网关应用层及以上。VLAN工作在数据链路层。

467. 集线器（Hub） ：物理层设备，共享带宽，冲突域扩大。

468. 交换机：数据链路层设备，基于MAC地址转发，隔离冲突域。

469. 路由器：网络层设备，基于IP地址转发，隔离广播域。

470. 网关：应用层及以上，协议转换。

471. OSI七层：物理层 → 数据链路层 → 网络层 → 传输层 → 会话层 → 表示层 → 应用层。

472. TCP/IP四层：网络接口层 → 网际层 → 传输层 → 应用层。

473. TCP特点：可靠、面向连接、面向字节流。三次握手建立连接，四次挥手释放连接。

474. UDP特点：快、无连接、面向报文，适合视频/语音/DNS。

475. 三次握手：SYN → SYN+ACK → ACK，防止已失效的连接请求突然到达。

476. 四次挥手：FIN → ACK → FIN → ACK，因为TCP是全双工的。

477. 常见端口：80-HTTP，443-HTTPS，21-FTP，53-DNS，25-SMTP，110-POP3。

478. SMTP：发送邮件；POP3/IMAP：接收邮件。

479. HTTP：超文本传输协议，无状态，默认端口80。

480. HTTPS：HTTP over SSL/TLS，默认端口443，加密传输。

481. DNS：域名解析，通常使用UDP 53端口。

482. FTP：文件传输，使用TCP，控制连接21，数据连接20（主动模式）。

483. IP地址分类：A类1—126，B类128—191，C类192—223，D类组播，E类保留。

484. 私有地址：10.0.0.0/8、172.16.0.0/12、192.168.0.0/16。

485. 子网掩码核心公式：可用主机数 = 2^h − 2（h主机位）；前缀 = 32 − h。

486. 子网掩码对照表：/25→126，/26→62，/27→30，/28→14，/29→6，/30→2。

487. 看到“30台”直接反应 /27，255.255.255.224；看到“62台”直接反应 /26，255.255.255.192。

488. CIDR：无分类域间路由，如192.168.1.0/26，前缀表示网络位数。

489. 网络地址：主机位全0；广播地址：主机位全1。

490. 加密与签名：公钥加密，私钥签名。加密用对方公钥，签名用自己私钥。

491. 对称加密：加密解密同一密钥，速度快，如DES、3DES、AES。

492. 非对称加密：公钥和私钥配对，如RSA、ECC。

493. 数字签名的作用：保证不可否认性和完整性，不保证机密性。

494. 数字证书：由CA签发，绑定公钥与身份。

495. 哈希算法：SHA-256属于哈希；RSA、ECC属于非对称加密。

496. 哈希函数特性：任意长度输入 → 固定长度输出，不可逆。

497. 防火墙类型：包过滤防火墙（速度快、粒度粗）；应用代理网关防火墙（检查应用层、速度慢）；状态检测防火墙（兼顾安全与速度）。

498. 网络攻击类型：DDoS（流量压垮）、ARP欺骗（伪造MAC-IP）、SQL注入（拼恶意SQL）、XSS（塞恶意脚本）、重放攻击（重发截获的认证报文）。

499. 病毒类型：Worm蠕虫（自我复制传播）、Trojan木马（伪装）、Backdoor后门、Macro宏病毒（感染文档）。

500. 入侵检测：专家系统、模型检测、简单匹配，分为基于主机和基于网络。

501. VPN：虚拟专用网，通过加密隧道在公共网络上传输私有数据。

502. SSL/TLS：传输层安全，为应用层提供加密和认证。

503. IPSec：网络层安全，常用于VPN。

504. 访问控制：自主访问控制（DAC）、强制访问控制（MAC）、基于角色的访问控制（RBAC）。

505. RBAC：将权限赋予角色，用户通过角色获得权限，简化管理。

506. 安全威胁：中断（破坏可用性）、截获（破坏机密性）、篡改（破坏完整性）、伪造（破坏真实性）。

507. 计算机犯罪：非法侵入、破坏数据、传播病毒、网络诈骗。

508. 网络安全等级保护：分等级保护、分等级监管。

509. 无线网络安全：WEP（已不安全）、WPA/WPA2（较安全）。

510. 电子邮件安全：PGP、S/MIME，用于加密和签名邮件。

使用建议：510条中，真题重复密度最高的是 1—10（CPU与码制）、13—18（校验与流水线）、66—78（进程与死锁）、131—162（数据结构与排序）、266—316（软件工程）、351—360（UML关系）、411—432（数据库范式与事务）、466—497（网络与加密） 。优先把这些背到条件反射，其余条目在刷真题时遇到再回头巩固。

一、数据流图（DFD）—— 15 分必拿题

数据流图考的是“把业务文字翻译成图，再把图里的错误找出来”。四个元素必须条件反射地识别：

• 外部实体：系统边界之外的“人/组织/外部系统”。题干中的“用户、客户、管理员、银行、供应商”都是实体词。注意：如果系统本身是中间件，后台数据库反而应识别为外部实体。
• 数据存储：名字带“文件、表、库、清单、档案”的，基本就是存储。找到存储后，看哪个加工需要读写它，补连线。
• 加工：命名必须是“动词 + 名词”（如“生成报告”“验证借书证”），不能只有一个动词。
• 数据流：命名必须是名词短语（如“工资数据”“付款通知”），不能写成“计算工资” ——用加工名命名数据流是最高频的扣分点之一。

答题顺序：先读题干圈出所有实体词和存储词 → 对比顶层图与 0 层图的输入输出是否一致 → 逐句读题干，看哪个加工“提到要读某存储但图上没有入线/出线” → 补全缺失的数据流。

三大铁律（违反必扣分） ：数据存储之间不能直连；外部实体之间不能直连；每个加工必须有入有出，不能是“数据黑洞”或“数据奇迹”。

采分要点：补充数据流时用题干原词，不要自己发明口语化名称；答案写成“在加工 Y 与存储 Z 之间添加数据流‘XX 信息’”，方向要明确。

二、数据库设计 —— 15 分必拿题

先找实体，不要先想表。实体通常是业务中需要长期管理的对象（客户、订单、商品、学生、课程）。

E-R 转关系模式三规则（直接背） ：

• 1 : 1：任一方主键放入另一方作外键（或两表合并）。
• 1 : N：1 端的主键放入 N 端作外键。例如客户和订单，订单表里保存客户编号。
• M : N：必须单独建一张联系表，字段 = 双方主键 + 联系自身的属性（如选课成绩、选课时间）。不能把课程编号直接塞进学生表。

主键与外键判定：题干出现“唯一标识”“编号”“身份证号”的，基本是主键候选。A 表里出现了 B 表的主键，它就是外键。M:N 联系表中，双方主键的组合是主键，同时各自也是外键。

范式判断（只看依赖关系） ：

• 1NF：属性不可再分。
• 2NF：消除部分依赖（非主属性不能只依赖联合主键的一部分）。
• 3NF：消除传递依赖（非主属性不能经由另一个非主属性间接依赖主键）。题给 A→B、B→C 且 B 不是候选键，就是传递依赖。

SQL 题：多表查询必须写 JOIN 和连接条件，漏掉连接条件会变成笛卡尔积。WHERE 过滤行，HAVING 过滤分组后的组。

三、UML 建模 —— 15 分必拿题

高频图种：用例图、类图、顺序图（时序图）。

类图六种关系（由弱到强，必须背熟） ：依赖 → 关联 → 聚合 → 组合 → 泛化 → 实现。

• 依赖：一个类的变化“波及”另一个（方法参数/局部变量中使用）。
• 关联：成员变量，“拥有”关系。
• 聚合：空心菱形，“has-a”，整体消失部分还在（如部门与员工）。
• 组合：实心菱形，“contains-a”，同生共死（如订单与订单项）。
• 泛化：继承，空心三角实线。
• 实现：类实现接口，虚线三角。

多重度：1 恰好一个；0..* 或 * 零个或多个；1..* 至少一个。注意“0”的含义（新系统刚上线可以没有订单）。

用例关系：include 是“一定会做”（如借书一定验证借书证），extend 是“有条件才做”（如超期才触发罚款）。常见错误是把系统内部模块标成参与者，或把实现步骤拆成过细的用例。

类图扣分点：业务分析层面的类图不应该出现 getter/setter 等纯技术方法，应列出与业务规则相关的核心操作。

四、C 语言算法设计 —— 15 分稳分题

这道题不需要从零写算法，而是在已搭好框架的代码里补全关键几行。题型结构固定：代码填空（6—9 分）+ 策略识别（约 3 分）+ 复杂度分析（约 3 分）+ 实例推演（约 3 分）。

四种策略的“长相”必须条件反射：

• 分治：递归框架 + 合并步骤（归并排序、二分查找、最大子数组）。填空常考递归终止条件和合并操作。
• 动态规划：有递推式/状态转移方程，通常填表自底向上。常考状态转移方程和填表顺序（0-1 背包、最长公共子序列）。
• 贪心：每步选当前最优、不回溯（活动选择、哈夫曼、Dijkstra）。常考贪心选择条件。
• 回溯：递归尝试 + 剪枝 + 恢复现场。填空三件套：递归出口、递归调用（参数推进）、回溯还原（把标记恢复为初始值） 。没有还原语句，回溯法就不成立。

“背了就有分”的部分：策略识别题从“分治/动态规划/贪心/回溯”中选；快排/归并的时间复杂度是 (O(n\log n))，暴力递归是 (O(2^n))，这些直接写。

考场策略：目标 7—10 分，不要在一道题上超过 25 分钟。就算代码没完全读懂，根据题干描述和代码结构，策略题蒙一个也有概率对。

五、设计模式选答（Java / C++）—— 15 分送分题

第 5/6 题二选一，选自己最擅长的语言。题型是“业务场景 + UML 类图 + 挖 5—6 个空的代码”，填空内容基本是类名、方法名、继承/实现关键字、返回类型、new 具体类这些有规律的东西。

高频模式（背 6 个足够） ：单例、简单工厂/工厂方法、策略、装饰器、观察者、适配器。

固定做题顺序：① 先认模式（看类名和场景关键词）→ ② 给类分角色（谁是接口、谁是具体实现、谁是客户端）→ ③ 扫完整段代码再填 → ④ 判断每个空属于哪一类：关键字 / 类型 / 方法签名 / 返回值 / new 对象 / 方法调用 → ⑤ 利用后文反推前文。

各模式填空重点：

• 单例：私有静态实例、私有构造器、getInstance()。
• 工厂方法：抽象工厂方法返回接口类型，具体工厂里 return new 具体产品()。
• 策略/装饰器/观察者：重点在接口方法的实现和上下文/主题中持有抽象类型的成员变量。

避免 Java 细节丢分：方法签名要完整（返回类型 + 方法名 + 参数）；字段声明不能漏类型；非 static 方法调用写成 obj.method()；父类字段的 private/protected 看后文谁在访问来决定；题目已有的名字直接照抄，注意大小写。

目标：这题模板背熟，拿 10—12 分是正常水平，冲满分完全可能。

六、下午题整体考场策略

时间分配建议：数据流图、数据库、UML 三题控制在 25—30 分钟内完成，确保 12 分以上；算法题留 20—25 分钟，目标 7—10 分；设计模式题 15—20 分钟，目标 10 分以上。先做有把握的题型，把“必拿分”锁死，再攻算法。

最容易丢分的细节汇总：数据流用动词命名；M:N 忘记单独建表；聚合/组合菱形实心空心搞反；回溯填空漏掉“还原”；设计模式填空方法签名不完整或返回类型写错。

把以上规则练到条件反射，下午卷的底线分（45 分）会非常稳，往上冲 55—60 分也有清晰路径。

一、上午选择题必背清单

（一）计算机组成与体系结构（约12分）

1. 流水线计算

• 背熟：流水线周期 = 各段中最慢的那段时间。执行时间 = 单条指令完整时间 +（指令数 − 1）× 流水线周期。吞吐率 = 指令数 / 总时间。
• 通俗：像工厂装配线，速度由最慢工位决定；第1条走完全程，之后每条只再等“最慢工位”那么久。

2. 浮点数

• 背熟：阶码决定范围，尾数决定精度。阶码越长范围越大，尾数越长精度越高。

3. Cache

• 背熟：Cache 是除寄存器外最快的存储层次，缓解 CPU 与主存之间的速度矛盾，依据是局部性原理。

4. 校验码

• 背熟：奇偶校验只检错不纠错；CRC 可检错不可纠错；海明码可检错也可纠错，校验位公式 2^r ≥ r + m + 1（m 数据位，r 校验位）。

5. 码制转换

• 背熟：正数原码、反码、补码相同；负数反码 = 原码数值位按位取反（符号位不变），补码 = 反码末位加1；移码 = 补码符号位取反。
• 通俗：补码存在的唯一目的，是让减法能用加法电路完成，省掉一套减法硬件。
• 常考：问“补码的作用”，选“将减法转化为加法，简化运算器设计”。

6. 寻址方式（高频辨析）

• 背熟：立即寻址最快（操作数写在指令里，不访存）；间接寻址最慢（多次访存）；寄存器寻址也快；直接寻址指令中放的是操作数地址。
• 通俗：立即=答案写在题目里；直接=题目给房间号；间接=题目给信封，信封里才是房间号。

7. 总线分类

• 背熟：数据总线双向，地址总线单向（CPU发出地址），控制总线双向。

8. 系统可靠性计算

• 背熟：串联可靠度 = 各部件相乘；并联可靠度 = 1 − 各部件失效率相乘（即 1 − (1−R)ⁿ）。
• 通俗：串联像铁链，一环断全断，所以乘；并联像多条备份路线，全断才断，所以算“全坏”再1减。
• 易错：并联不是直接相乘可靠度，是先求全失效概率再1减。

9. I/O 数据传输方式

• 背熟：效率 DMA > 中断 > 程序查询。程序查询 CPU 一直等，利用率最低；中断 CPU 不用等但每次传输要介入；DMA 硬件直接搬数据，CPU 几乎不参与。

（二）操作系统（约10分）

1. PV操作与前趋图

• 背熟：互斥信号量初值1，同步信号量初值通常0。前趋图中，箭线起点是 V（前驱完成通知），终点是 P（后继开始前等待）。
• 通俗：P 是申请/等待，V 是释放/通知；谁先完成谁 V，谁要开始谁先 P 等着。

2. 死锁判断

• 背熟：不会死锁的条件 m * (w-1) + 1 <= n（m 进程数，w 每进程最大需求，n 资源总数）。
• 通俗：最坏情况每个进程都拿到“差一个就满足”，此时再多1个资源，必能先让一个进程跑完，打破死锁。

3. 页式存储

• 背熟：逻辑地址 = 页号 + 页内偏移。淘汰页面时，被修改过的脏页要写回磁盘，没修改的直接丢弃。

4. 线程与进程资源共享（高频易混）

• 背熟：同进程内多线程共享代码段、全局变量、打开的文件；但每个线程有独立栈和寄存器，栈不共享。
• 通俗：进程像办公室，代码和文件是公共资源；但每个人的**工位（栈）**是自己的。

5. 文件物理结构

• 背熟：连续结构存取快但产生碎片；链接结构无碎片但只能顺序访问；索引结构支持随机访问，索引表占空间。
• 常考：“支持随机存取且不产生外部碎片”选索引结构。

（三）数据结构与算法（约10分，性价比最高）

1. 排序复杂度与稳定性（几乎年年沾边）

• 背熟：
  • 平均 (O(n\log n))：快排、归并、堆排（口诀“快归堆”）。
  • 平均 (O(n^2))：冒泡、插入、选择（口诀“冒插选”）。
  • 不稳定：快排、希尔、选择、堆排（口诀“快希选堆”）。
  • 稳定：冒泡、插入、归并、基数。
• 通俗：稳定性指“值相等的元素排序后相对顺序不变”，需要保留原始先后顺序的场景必须用稳定排序。

2. 二叉树遍历

• 背熟：前序“根左右”，中序“左根右”，后序“左右根”。已知中序 + 前序（或中序 + 后序）可唯一还原二叉树。

3. 哈夫曼树

• 背熟：权值小的优先合并，带权路径长度最小；频率高的字符编码短。

4. 图的存储与遍历

• 背熟：邻接矩阵适合稠密图，邻接表适合稀疏图。DFS 用栈（递归），BFS 用队列。
• 通俗：邻接矩阵像“谁和谁相连”的大表格，边多填得满才划算；边少大部分是空的，就用邻接表只记朋友。

5. B树与B+树

• 背熟：B树节点既存关键字也存数据；B+树只有叶子节点存数据，非叶子只存索引，叶子间用指针连成链表，范围查询更快。数据库索引多用 B+ 树。

6. 关键路径

• 背熟：关键路径是 AOE 网中最长路径，关键活动时间裕量为 0，任何关键活动延误都拖长总工期。

（四）程序设计语言基础

1. 编译各阶段

• 背熟：词法分析 → 语法分析 → 语义分析 → 中间代码生成 → 优化 → 目标代码生成。词法管“单词拼写”，语法管“句子结构”，语义管“意思通不通”。
• 常考：“括号不匹配”在语法分析阶段发现。

2. 有限自动机与正规式

• 背熟：DFA 每个状态对同一输入只有唯一后继；NFA 可有多个后继。正规式与有限自动机等价，都描述词法规则。

3. 编译 vs 解释

• 背熟：编译效率高但可移植性差；解释可移植性好但效率低。

（五）软件工程

1. 开发模型

• 背熟：瀑布阶段严格顺序，适合需求明确稳定；敏捷迭代、快速响应变化（Scrum 每日站会、XP 结对编程）；螺旋强调风险分析，适合大型复杂项目。

2. 内聚与耦合

• 背熟：内聚从高到低：功能 > 顺序 > 通信 > 过程 > 时间 > 逻辑 > 偶然。耦合从低到高：非直接 > 数据 > 标记 > 控制 > 外部 > 公共 > 内容。设计目标：高内聚低耦合。

3. McCabe 环路复杂度

• 背熟：边 − 节点 + 2，或 判定节点数 + 1。两种结果一样，考场用“判定节点数 + 1”更快。
• 通俗：数的是代码里有多少个岔路口，岔路越多测试要覆盖的路径越多。

4. 测试与维护

• 黑盒：等价类划分、边界值分析（不关心内部逻辑）。
• 白盒：逻辑覆盖（语句、判定、条件、路径覆盖）。
• 维护类型：纠错性（修bug）、适应性（环境变化）、完善性（加功能）、预防性（提高可维护性）。

5. 可移植性设计

• 背熟：核心是屏蔽平台差异——设备相关代码与无关代码分离、用跨平台语言、不用平台专属类库。“使用特定环境专用功能”是破坏可移植性的做法，选项里出现不要选。

（六）面向对象

1. UML 核心图

• 背熟：用例图看“系统能做什么”；类图看静态结构；时序图看按时间顺序的消息交互；活动图看流程；状态图看对象状态变迁。

2. 类图关系强弱

• 背熟：依赖 < 关联 < 聚合 < 组合 < 泛化（继承）< 实现。聚合空心菱形（整体没了部分还能活），组合实心菱形（整体没了部分跟着销毁）。

3. 设计模式三大分类

• 背熟：创建型管“怎么造对象”（单例、工厂、建造者、原型）；结构型管“怎么拼对象”（适配器、桥接、组合、装饰、外观、享元、代理）；行为型管“对象之间怎么通信分责”（观察者、策略、命令、模板方法、责任链、状态、迭代器等）。
• 场景对应：只需一个实例→单例；接口不兼容要转换→适配器；一对多通知→观察者；多种算法可互换→策略；两个独立变化维度→桥接。

（七）数据库系统

1. E-R 转关系模式（送分核心）

• 背熟：1:1 任一方主键放进另一方作外键；1:N 把 1 端主键放进 N 端作外键；M:N 必须单独建表，主键 = 双方主键的组合，联系自身属性也放这张表。
• 通俗：多对多像“学生选课”，选课关系（成绩）塞不进学生表或课程表，只能单独建“选课表”。

2. 规范化

• 背熟：1NF 属性不可再分；2NF 消除部分依赖（联合主键中某字段不能只依赖主键一部分）；3NF 消除传递依赖（非主属性不能依赖另一个非主属性）。

3. 三级模式与两级映像

• 背熟：三级模式 = 外模式（用户视图）、模式（逻辑结构）、内模式（物理存储）；两级映像 = 外模式/模式（逻辑独立性）、模式/内模式（物理独立性）。
• 通俗：外模式是“你看到的报表”，模式是“数据库表结构设计”，内模式是“数据在硬盘怎么存”。改硬盘不影响表结构（物理独立性），改表结构不影响报表（逻辑独立性）。

4. 事务与封锁

• 背熟：ACID = 原子性、一致性、隔离性、持久性。一级封锁防丢失修改，二级防脏读，三级防不可重复读。

5. SQL 要点

• 背熟：WHERE 过滤行，HAVING 过滤分组后的组。多对多查询必须通过中间关联表 + JOIN。

（八）计算机网络与信息安全

1. 子网划分（必考计算）

• 背熟核心：可用主机数 = (2^h - 2)（h 主机位）；子网掩码前缀 = (32 - h)；子网数 = (2^n)（n 借位数）。
• 必背对照表：

看到“30台”→/27，255.255.255.224；看到“62台”→/26。

2. 网络设备工作层次

• 背熟：集线器（Hub） 物理层，交换机数据链路层，路由器网络层，网关应用层及以上。

3. 协议端口

• 背熟：80-HTTP，443-HTTPS，21-FTP，53-DNS，25-SMTP，110-POP3。TCP 可靠、面向字节流、有连接；UDP 快、无连接、面向报文（适合视频/语音/DNS）。

4. 加密与签名

• 背熟：公钥加密，私钥签名。加密用对方公钥，签名用自己的私钥。数字签名保证不可否认性；数字证书由 CA 签发，绑定公钥与身份。

5. 常见攻击

• 背熟：DDoS 分布式拒绝服务（流量压垮）；ARP 欺骗伪造 MAC-IP 对应；SQL 注入拼恶意 SQL；XSS 塞恶意脚本。防护对应：流量清洗、ARP 绑定、参数化查询、输入转义。

（九）知识产权与标准化（纯记忆）

1. 保护期限

• 背熟：公民软件著作权 作者终生 + 死后50年；单位软件著作权 首次发表后50年；注册商标 10年（期满前6个月续注）；发明专利 20年；实用新型和外观设计 10年。
• 特殊：署名权、修改权、保护作品完整权保护期不受时间限制。

2. 标准代号

• 背熟：GB 强制性国标，GB/T 推荐性国标，ISO 国际标准，IEEE 行业标准。

二、CPU 组成结构专题（你特别问的）

总原则：不需要逐字背教材每个寄存器，但核心部件 + 归属判断必须背熟，因为常考“下列哪个属于运算器/控制器”。

1. 必须背熟的核心结论

CPU 两大核心部件：运算器 + 控制器（外加寄存器组、内部总线）。

运算器：背“算、存、状”

• ALU 算术逻辑单元：做算术和逻辑运算，运算器核心。
• AC 累加寄存器：暂存运算结果或操作数。
• DR 数据缓冲寄存器：暂存从内存读出或要写入内存的数据。
• PSW 状态条件寄存器（标志寄存器）：存进位、溢出、零标志等状态。

记忆：运算器 = ALU + AC + DR + PSW。

控制器：背“取、译、时、发”

• PC 程序计数器：存下一条要执行指令的地址。
• IR 指令寄存器：存当前正在执行的指令。
• 指令译码器：把操作码翻译成控制信号。
• 时序部件/微操作信号发生器：产生各阶段时序控制信号。

记忆：控制器 = PC + IR + 译码器 + 时序部件。

2. 必须背熟的归属判断（高频易错）

• PC 属于控制器（不是运算器）。
• IR 属于控制器（不是运算器）。
• ALU 属于运算器。
• PSW 属于运算器。
• 指令译码器属于控制器。

只要能把上面几个正确归类，这类选择题就不会丢分。

3. 理解即可、不必死背

• 通用寄存器组：CPU 内部暂存操作数，软考有时单列，不一定强行归入运算器。
• 暂存寄存器、内部总线：知道是 CPU 内部数据通路一部分即可。
• 控制器产生控制信号的具体流程：理解“取指—译码—执行”顺序即可，不必背微操作序列。

4. 一句话背诵版

运算器四件套：ALU、AC、DR、PSW；控制器四件套：PC、IR、译码器、时序部件。PC 存下一条，IR 存当前条；PC、IR 归控制器，ALU、PSW 归运算器。

三、下午应用题必背（题型固定，背模板拿底线分）

下午前4题必答，题型极其固定。目标不是现场设计，而是“看到题就知道第一步找什么”。

（一）数据流图（第1题，15分）

背熟三件事：

1. 外部实体：题干里的“人/部门/外部系统”（客户、管理员、银行、财务部门等），系统边界之外。
2. 数据存储：名字带“文件、表、清单、档案、库”的基本是数据存储。
3. 缺失数据流：先找“只有入没有出”或“只有出没有入”的加工；再逐句读题干，看哪个加工“提到要读某存储但图上没入线”。数据流起点或终点必须有一个是加工。

三条铁律：数据存储之间不能直连；外部实体之间不能直连；加工不能只有入或只有出。都必须经过加工中转。

命名规范：数据流写名词（如“付款通知”），不能写成“计算成本”这种加工名；加工名写动词+名词。

数据平衡三原则：

• 父图与子图平衡：子图边界流 = 父图该加工的流，一条不多一条不少。
• 加工自身平衡：每个加工有进有出，不能是黑洞或奇迹。
• 顶层图与0层图平衡：系统对外交互数量名称一致。

父图子图通俗：父图是粗图，子图是把父图中某一个加工展开后的细图；平衡要求这个框的对外接口展开前后不能变。

（二）数据库设计（第2题，15分）

E-R 转关系模式规则（送分核心）：

• 1:1：任一方主键放进另一方作外键（或合并）。
• 1:N：N 端加 1 端主键作外键。
• M:N：必须单独建表，主键 = 双方主键组合，联系自身属性也放这张表。

主键判定：题干出现“唯一标识”“编号”“身份证号”的基本是主键候选。

外键判定：A 表出现 B 表主键，它就是外键；M:N 单独建的表，双方主键组合为主键，同时各自也是外键。

范式一句话：1NF 列不可分；2NF 消除部分依赖；3NF 消除传递依赖。

（三）UML 建模（第3题，15分）

类图关系：泛化（空心三角实线，继承）、聚合（空心菱形，整体没了部分还能活）、组合（实心菱形，部分随整体销毁）、依赖（虚线箭头，一个类变化波及另一个）。

多重度：1 恰好一个；0..* 或 * 零个或多个；1..* 至少一个。注意“0”的含义（新系统刚上线没有订单）。

用例关系：include 是“一定会做”，extend 是“有条件才做”。

（四）C 语言算法设计（第4题，15分）

四种策略的“长相”：

• 分治：大问题拆小问题，递归求解再合并（归并排序、二分查找）。
• 动态规划：有递推式/状态转移方程，通常用表格自底向上算。
• 贪心：每步选当前最优，不回头（活动安排、部分背包）。
• 回溯：递归尝试 + 不满足就撤销（N皇后、排列组合）。

填空三件套：

• 递归出口：函数开头，看终止条件（如 row > n），不要填成推进条件。
• 递归调用：参数推进通常是 row+1、k+1、i+1，看“处理下一个”用哪个变量控制。
• 回溯还原：找前面“标记占用”的语句，把它恢复初始值（如 queen[row]=0、visited[i]=0）。没有还原语句，回溯法就不成立。

经典结论：N皇后 n=4 时解的个数 = 2。

策略：目标6—8分，不要在一道算法题耗超过25分钟。

（五）设计模式选答（第5/6题，15分选一）

背熟“场景→模式”对应：

• 单例：系统只需要一个实例（连接池、配置管理器、中央控制器）。
• 工厂：创建对象逻辑集中管理，调用方只说“要什么”。
• 观察者：一对多通知，一个对象变了所有依赖它的自动更新（事件监听、温度触发空调）。
• 策略：多种可互换算法，运行时选一种（不同促销规则）。
• 适配器：接口不兼容要转换。
• 桥接：两个独立变化的维度，用组合而非继承。

代码填空三处：接口/抽象类的实现关键字（Java 是 implements，C++ 是 : public）、工厂方法的返回类型（填接口名）、具体对象的创建（填 new 具体类()）。

策略：选自己最擅长的语言，考前集中练真题填空；能拿一半分就足以通过。

四、背诵优先级与速记口诀

时间紧张先背这些

上午题最容易被忽略但几乎年年出现：码制补码作用、寻址方式快慢排序、总线单向/双向、串联并联可靠度、DMA>中断>查询、线程不共享栈、McCabe 边−节点+2、可移植性“不用专用功能”、三级模式两级映像、设计模式三大分类、Hub/交换机/路由器层次、CPU 运算器/控制器归属。

下午题最容易丢分的细节：数据流命名不能用动词、缺失流必须一端是加工、M:N 单独建表且主键为组合、聚合 vs 组合看菱形实心空心、回溯填空必有“还原”、设计模式填空看 implements 和 new。

一句话总口诀

上午背：流水线周期 + PV方向 + 排序口诀 + 子网对照表 + 保护期限 + CPU四件套归属。
下午背：DFD找实体/存储 + E-R的M:N单独建表 + 类图关系/多重度 + 四种算法长相 + 六种模式场景。
CPU专题：运算器 ALU/AC/DR/PSW，控制器 PC/IR/译码器/时序部件；PC、IR 归控制器，ALU、PSW 归运算器。

把以上条目背到条件反射，上午选择题的“概念辨析+小计算”和下午前四题的“模板采分”就基本没有大块盲区。专业英语（5分）不建议专门背单词，靠做真题积累计算机术语即可；知识产权分值低，背列出的保护期限和标准代号就够，把时间优先给软件工程、面向对象、数据结构与算法这三块约30分的重心。

关于“已知每个子网主机数，求子网掩码”这一类题，需要记住的核心是主机位公式 + 掩码换算 + 常见掩码表。下面按类别列出关键知识点和常考形式。

一、必须背熟的核心公式

1. 可用主机数公式

[ 可用主机数 = 2^h - 2 ]

• (h)：主机位数
• 减 2：去掉网络地址和广播地址
• 题目说“每个子网主机数是30台”，就是求满足 (2^h-2 \ge 30) 的最小 (h)

2. 子网掩码前缀

[ 子网掩码前缀 = 32 - h ]

因为 IPv4 共 32 位，主机位占 (h) 位，剩下全是网络位/子网位。

3. 子网数公式

[ 子网数 = 2^s ]

• (s)：从主机位借来用作子网位的位数
• 常考：“划分成若干子网”求子网数或掩码

4. 每个子网地址总数

[ 地址总数 = 2^h ]

可用主机数 = 地址总数 − 2。

二、必须背熟的常见掩码表

记忆重点：

• 看到“30台主机” → 直接想到 /27，255.255.255.224
• 看到“62台” → /26
• 看到“14台” → /28
• 看到“6台” → /29
• 看到“2台” → /30（常用于点对点链路）

三、C类地址的默认知识

• C类地址默认网络位：24位
• 默认子网掩码：255.255.255.0（/24）
• 默认主机位：8位
• 划分子网时，只能从最后 8 位主机位中“借位”作子网位

所以 C 类题中，掩码变化只在最后一个字节。

四、常考题型与对应解法

题型1：已知每个子网主机数，求子网掩码

• 解法：用 (2^h-2 \ge 主机数) 求最小 (h)，再算前缀 (32-h)，转点分十进制。
• 例：30台 → h=5 → /27 → 255.255.255.224

题型2：已知子网掩码，求每个子网可用主机数

• 解法：先看前缀，求 (h=32-前缀)，再算 (2^h-2)。
• 例：/28 → h=4 → 14台

题型3：已知需要划分的子网数，求子网掩码

• 解法：用 (2^s \ge 子网数) 求最小 (s)，新前缀 = 默认前缀 + s。
• 注意：这题问的是“子网数”，不是“每子网主机数”，不要混。

题型4：求网络地址、广播地址、可用IP范围

• 解法：用“块大小 = 256 − 掩码最后字节”定位。
• 例：/27 最后字节224，块大小 = 256−224 = 32。
• 网络地址是块大小的整数倍起点；广播地址是下一个块起点减1。

题型5：判断两个IP是否在同一子网

• 解法：分别与子网掩码做按位与，结果相同则同子网。

五、易错点（软考常设陷阱）

1. 忘记减2：可用主机数不是 (2^h)，而是 (2^h-2)。
2. 把“主机数”当成“地址总数”：30台主机对应32个地址，不是30个地址。
3. 借位方向搞反：子网位是从主机位借，前缀变大，主机位变小。
4. C类默认/24忘记：C类不是/16，A类/8、B类/16、C类/24。
5. /30不是不能用：/30只有2个可用主机，点对点链路常用；/31是特殊点对点，软考一般按传统减2理解。
6. “子网数”和“每子网主机数”混淆：一个用 (2^s)，一个用 (2^h-2)。

六、速记口诀

主机数先加2，找最小2的幂；
主机位定h，前缀就是32减h；
C类默认24，最后字节来换算；
30台记/27，掩码末位224。

你给的题“C类地址每个子网30台主机”，直接背成：30台 → h=5 → /27 → 255.255.255.224。这是软考网络计算题里最高频的结论之一。

CSP（通信顺序进程）是由图灵奖得主托尼·霍尔提出的并发系统代数理论‌，核心思想是通过独立进程间的显式消息通信替代共享内存，从根源上降低并发编程的复杂度。

📜 理论起源与发展

• 1978年，英国计算机科学家 ‌托尼·霍尔‌ 首次正式阐述CSP理论，1985年出版同名专著《Communicating Sequential Processes》。
• 1984年，霍尔与合作者提出TCSP理论，扩展出事件隐蔽、递归等核心算子，形成完整的基于事件的代数演算系统。

CSP 是 Tony Hoare（图灵奖得主，快速排序的发明者）在 1978 年发表的一篇同名论文中提出的并发编程理论模型。它的核心主张极其简洁：

不要通过共享内存来通信，而应该通过通信来共享内存。

“Do not communicate by sharing memory; instead, share memory by communicating.”

这句话后来成为 Go 语言并发哲学的灵魂，也是 Go 官方文档里反复强调的设计原则。理解 CSP，才能理解为什么 Go 的并发原语长成 goroutine + channel + select 这个样子。

一、CSP 要解决什么问题

在 CSP 出现之前，并发编程的主流范式是共享内存 + 锁。多个线程读写同一块内存，靠互斥锁、信号量、条件变量保证正确性。这种范式的问题在实践中暴露得非常充分：

CSP 提出的思路是从根本上取消共享内存这个媒介：每个并发实体（在 CSP 里叫"进程"，在 Go 里叫 goroutine）拥有私有的状态，它们之间只能通过消息传递来交换数据。既然没有共享内存，就不需要锁，竞态和死锁问题在模型层面被大幅消解。

二、CSP 的核心抽象

CSP 理论模型里有三个基本要素：

2.1 进程（Process）

一个独立的、顺序执行的实体。它有自己的局部状态，按照既定逻辑一步步执行。在 Go 里，这就是 goroutine——一个由运行时调度的轻量级执行单元。

2.2 通道（Channel）

进程之间唯一的通信媒介。通道是有类型的、单向或双向的、可阻塞的消息队列。发送方把数据放入通道，接收方从通道取出数据。CSP 的关键在于：

• 通道是同步点：无缓冲通道上的发送和接收必须"会合"才继续，这天然形成了一种"握手"式的同步。
• 通道是唯一的数据通路：进程不共享内存，数据从发送方"移动"到接收方，而不是被两边同时看到。

Go 的 chan T 就是通道的直接实现。

2.3 选择（Choice / Select）

进程可以同时等待多个通道操作，哪个先就绪就走哪个分支。这是 CSP 的"守卫命令"（guarded command）在工程上的落地。Go 的 select 语句就是它的实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

select {
case msg := <-ch1:
    // ch1 有数据
case ch2 <- data:
    // ch2 可以发送
case <-timeout:
    // 超时
default:
    // 没有就绪的，走默认分支（非阻塞）
}

select 让"等待多个通信事件"成为一等公民，这是 CSP 区别于简单队列模型的标志性能力。

三、CSP 在 Go 中的完整映射

关键点：Go 的 channel 不是简单的"线程安全队列"，它是 CSP 同步语义的载体。无缓冲通道的阻塞行为是设计意图，不是性能缺陷——它强制两个 goroutine 在某个时刻"对齐"，这种对齐本身就是一种同步原语，可以替代很多场景下的锁。

四、为什么"通过通信共享内存"更好

用一个经典对比来理解。假设两个 goroutine 要"谁先到谁设置一个标志"：

共享内存 + 锁的写法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var mu sync.Mutex
var done bool

// goroutine A
mu.Lock()
if !done {
    done = true
    // 做事情
}
mu.Unlock()

这里 done 是共享状态，mu 保护它，任何新增访问点都必须记得加锁。锁的保护范围和生命周期是人工维护的契约，容易漏。

CSP 的写法（用 channel 的关闭语义表达"只发生一次"）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

done := make(chan struct{})

// goroutine A
select {
case <-done:
    // 已经有人做过了
default:
    close(done)  // 只有 close 成功的人"赢得"了这次机会
    // 做事情
}

数据（“是否已完成"这个信息）通过 done 通道的关闭事件传递，而不是通过一个共享的布尔变量。没有锁，正确性由通道的关闭语义（close 只能成功一次）保证。

再看你之前代码里的实际例子——信号处理的 sigCh：

1
2
3
4
5
6

sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
go func() {
    sig := <-sigCh       // 阻塞等待信号
    cancel()             // 通过 context 通知
}()

信号从操作系统（一个"进程”）通过 sigCh（通道）传给处理 goroutine（另一个"进程"），数据是"信号"这个值。main 逻辑不共享任何"信号标志位"，而是通过 ctx.Done() 这个通道的关闭事件感知退出。整条链路没有一把锁，这正是 CSP 风格的典型体现。

五、CSP vs 其他并发模型

CSP 和 Actor 的关键区别：CSP 的通道是同步会合（无缓冲时发送方要等接收方），Actor 的邮箱是异步投递（发完就走）。CSP 里"谁接收"由通道的静态连接决定，Actor 里"发给哪个 Actor"是运行时动态路由。Go 的 channel 更接近 CSP，但通过缓冲通道也提供了部分异步能力，是一个折中实现。

CSP 和共享内存的关系：CSP 并非完全禁止共享内存——Go 里你依然可以用 sync.Mutex、atomic。CSP 是一种优先推荐的范式，不是强制约束。Go 官方文档的说法是：“channel 用于在 goroutine 之间传递数据的所有权；mutex 用于保护 goroutine 内部的数据结构”。两者各司其职，不是非此即彼。

六、CSP 的局限性与实践中要注意的地方

CSP 不是银弹，用它写代码依然会踩坑：

1. 通道也会死锁

两个 goroutine 互相等待对方从通道接收，就死锁了。Go 运行时有死锁检测（所有 goroutine 都阻塞时 panic），但只在"完全无进展"时触发，复杂的多通道场景可能检测不到。

2. 通道不是"免费"的

每个通道操作都有调度开销，大量极细粒度的通道通信（比如每个元素一个通道）性能可能不如一把锁保护一个切片。CSP 适合粗粒度、有明确交接语义的通信。

3. “共享内存"换了形式也可能回来

如果通过通道传递的是指针或 map 引用，接收方拿到后修改它，本质上还是在共享内存。CSP 的"私有状态"要求传递的是值或所有权转移，传指针会破坏这个前提。

4. select 的公平性

select 在多个 case 同时就绪时随机选择一个，不保证顺序。如果需要严格的优先级，得自己用嵌套 select 或额外逻辑实现。

5. 取消与超时需要额外机制

CSP 原生没有"取消"概念，Go 用 context 补上了这块。context.Done() 本身也是一个通道（<-chan struct{}），本质上还是用 CSP 的思想实现取消传播。

七、回到你的代码：CSP 视角的解读

回顾之前的 StateGraph 工程，几处设计都可以用 CSP 的语言来解释：

信号处理：sigCh 是操作系统与程序之间的通道，signal.Notify 注册的是"谁来接收”，消费 goroutine 通过阻塞接收实现同步。

并行扇出：weather、geo、github 三个节点在 langgraphgo 内部由独立的 goroutine 执行，它们各自返回状态副本（copyState），这是"私有状态"的体现；框架在合并时通过 Reducer 把结果"通信"回主状态，而不是让三个 goroutine 直接写同一个 map——这正是"通过通信共享内存"的实践。

人工中断：GraphInterrupt 本质上是把"暂停点"的状态通过返回值"传递"给调用方，调用方决策后再把状态"传回"恢复执行。状态在两次调用之间不是被共享的，而是被移交的。

HTTP 日志的 sync.Mutex：这里用的恰恰是共享内存 + 锁。因为日志文件是一个被多个 goroutine 并发写入的单一资源，用 Mutex 保护它比"每个请求一个通道再串行化写"更简单直接。这印证了前面说的：CSP 和锁不是对立，而是分工。通道适合"传递数据所有权"，锁适合"保护共享资源"。

八、总结

CSP 的价值不在于它提供了多少新原语，而在于它重新定义了并发实体之间的关系：从"竞争同一块内存"变成"通过通道交换消息"。这个视角转换带来的收益是：

• 正确性更容易推理：没有隐藏的共享状态，每个 goroutine 的行为只依赖它收到的消息
• 同步语义显式化：无缓冲通道的阻塞行为本身就是同步点，不需要额外的锁或条件变量
• 组合性更好：select 让多路通信的组合表达得非常自然，这是锁模型很难优雅实现的

Go 把 CSP 从理论变成了工程现实——goroutine 足够轻、channel 足够快、select 足够灵活，三者组合让 CSP 风格成为 Go 并发代码的默认写法。但正如所有模型一样，它有自己的适用边界：用通道传递数据和信号，用锁保护内部数据结构，用 context 传播取消——这三者配合，才是 Go 并发编程的完整图景。

text/template 是 Go 标准库自带的模板引擎，专门用于生成任意文本输出（HTML、配置文件、代码、Prompt 等）。下面从零讲到进阶，每个知识点都配可运行代码。

一、为什么需要模板引擎？

假设你要生成一段 Prompt：

1
2

// 字符串拼接
prompt := "你是一个" + role + "助手。请用" + style + "风格回答。"

一旦需求变复杂——要根据条件加 few-shot 示例、要循环生成示例、要做 A/B 实验——字符串拼接就变得难以维护。

模板引擎把"文案"和"逻辑"分离：

你是一个{{ .Role }}助手。请用{{ .Style }}风格回答。

代码只负责提供数据，模板负责渲染。

二、最小可运行示例

main.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
	"os"
	"text/template"
)

func main() {
	tmpl := template.Must(template.New("hello").Parse("你好，{{ .Name }}！你今年 {{ .Age }} 岁。\n"))

	data := map[string]any{
		"Name": "小明",
		"Age":  18,
	}

	if err := tmpl.Execute(os.Stdout, data); err != nil {
		panic(err)
	}
}

运行：

1

go run main.go

输出：

你好，小明！你今年 18 岁。

这就是模板的核心三步：Parse → Execute → 输出。

三、三个核心概念

关键点：

• Parse 只做一次，Execute 可以反复调用（并发安全）。
• Execute 的第二个参数就是模板里的 .（点）。

四、模板语法详解

1. 输出变量 {{ .字段 }}

1
2
3
4

tmpl := template.Must(template.New("x").Parse("{{ .Name }} 在 {{ .City }}\n"))
data := map[string]string{"Name": "小明", "City": "杭州"}
tmpl.Execute(os.Stdout, data)
// 输出：小明 在 杭州

2. struct 作为数据

1
2
3
4
5
6
7
8

type User struct {
	Name string
	Age  int
}

tmpl := template.Must(template.New("x").Parse("{{ .Name }} 今年 {{ .Age }} 岁\n"))
tmpl.Execute(os.Stdout, User{Name: "小明", Age: 18})
// 输出：小明 今年 18 岁

推荐用 struct：字段名写错会在编译期报错，比 map 更安全。

3. 条件判断 {{ if }} {{ else }} {{ end }}

1
2
3
4
5
6

const t = `{{ if .IsVIP }}尊贵的 VIP 用户{{ else }}普通用户{{ end }}，你好！
`
tmpl := template.Must(template.New("x").Parse(t))

tmpl.Execute(os.Stdout, map[string]bool{"IsVIP": true})
tmpl.Execute(os.Stdout, map[string]bool{"IsVIP": false})

输出：

尊贵的 VIP 用户，你好！
普通用户，你好！

if 会判断值是否为"零值"：false、0、""、nil、空切片都是假。

4. 循环 {{ range }}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

const t = `示例：
{{ range .Examples }}输入：{{ .Input }}
输出：{{ .Output }}
{{ end }}`

data := map[string]any{
	"Examples": []map[string]string{
		{"Input": "这家餐厅很棒", "Output": "正面"},
		{"Input": "太失望了", "Output": "负面"},
		{"Input": "今天天气不错", "Output": "中性"},
	},
}

tmpl := template.Must(template.New("x").Parse(t))
tmpl.Execute(os.Stdout, data)

输出：

示例：
输入：这家餐厅很棒
输出：正面
输入：太失望了
输出：负面
输入：今天天气不错
输出：中性

range 里 . 变成当前元素，所以 {{ .Input }} 取当前元素的字段。

5. 循环里的索引

1
2
3
4
5

const t = `{{ range $i, $v := .Items }}{{ $i }}: {{ $v }}
{{ end }}`

tmpl := template.Must(template.New("x").Parse(t))
tmpl.Execute(os.Stdout, map[string]any{"Items": []string{"a", "b", "c"}})

输出：

0: a
1: b
2: c

6. 变量 {{ $x := ... }}

1
2
3
4

const t = `{{ $name := .Name }}你好，{{ $name }}！{{ $name }}，欢迎回来。
`
tmpl := template.Must(template.New("x").Parse(t))
tmpl.Execute(os.Stdout, map[string]string{"Name": "小明"})

输出：

你好，小明！小明，欢迎回来。

变量在 {{ end }} 后失效，也可以在 range 外定义、内部使用。

7. 管道 {{ . | func }}

1
2
3
4

const t = `{{ .Name | printf "%s先生" }}{{ .Text | len }} 个字
`
tmpl := template.Must(template.New("x").Parse(t))
tmpl.Execute(os.Stdout, map[string]string{"Name": "小明", "Text": "你好世界"})

输出：

小明先生4 个字

管道把前一个结果作为后一个函数的最后一个参数。

8. 内建函数一览

9. 去除空白 {{- 和 -}}

模板里的换行和缩进会原样输出。用 - 可以吃掉两侧空白：

1
2
3
4
5

const t = `示例：
{{- range .Examples }}
输入：{{ .Input }}
{{- end }}
`

输出会去掉 range 和 end 行产生的空行。

10. 注释 {{/* ... */}}

1
2

const t = `{{/* 这是注释，不会输出 */}}你好，{{ .Name }}
`

五、多模板与嵌套

1. 定义命名模板 {{ define }}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const t = `
{{ define "greeting" }}你好，{{ .Name }}！{{ end }}
{{ define "body" }}欢迎使用本系统。{{ end }}

{{ template "greeting" . }}
{{ template "body" . }}
`

tmpl := template.Must(template.New("x").Parse(t))
tmpl.Execute(os.Stdout, map[string]string{"Name": "小明"})

输出：

你好，小明！
欢迎使用本系统。

2. 模板里调用模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

const t = `
{{ define "example" }}输入：{{ .Input }}
输出：{{ .Output }}
{{ end }}

示例：
{{ range .Examples }}{{ template "example" . }}{{ end }}
`

data := map[string]any{
	"Examples": []map[string]string{
		{"Input": "很好", "Output": "正面"},
		{"Input": "太差", "Output": "负面"},
	},
}

tmpl := template.Must(template.New("x").Parse(t))
tmpl.Execute(os.Stdout, data)

输出：

示例：
输入：很好
输出：正面
输入：太差
输出：负面

六、从文件加载模板

真实项目里模板通常放在文件里。

目录结构

.
├── main.go
└── tmpl/
    ├── greeting.tmpl
    └── example.tmpl

tmpl/greeting.tmpl

你好，{{ .Name }}！欢迎使用。

tmpl/example.tmpl

示例：
{{- range .Examples }}
输入：{{ .Input }}
输出：{{ .Output }}
{{- end }}

main.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import (
	"os"
	"text/template"
)

func main() {
	// 加载单个文件
	t1 := template.Must(template.ParseFiles("tmpl/greeting.tmpl"))
	t1.Execute(os.Stdout, map[string]string{"Name": "小明"})

	// 加载多个文件
	t2 := template.Must(template.ParseGlob("tmpl/*.tmpl"))
	// 指定用哪个模板渲染
	t2.ExecuteTemplate(os.Stdout, "example.tmpl", map[string]any{
		"Examples": []map[string]string{
			{"Input": "很好", "Output": "正面"},
			{"Input": "太差", "Output": "负面"},
		},
	})
}

关键点：用 ParseFiles / ParseGlob 加载多文件时，模板名就是文件名。渲染时用 ExecuteTemplate(w, "文件名", data) 指定用哪个。

七、自定义函数

模板可以注册自定义函数，扩展表达能力。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import (
	"os"
	"strings"
	"text/template"
)

func main() {
	funcs := template.FuncMap{
		"upper": strings.ToUpper,
		"trunc": func(n int, s string) string {
			if len(s) <= n {
				return s
			}
			return s[:n] + "..."
		},
		"add": func(a, b int) int { return a + b },
	}

	const t = `{{ .Name | upper }} 
{{ .Text | trunc 10 }}
1 + 2 = {{ add 1 2 }}
`

	tmpl := template.Must(template.New("x").Funcs(funcs).Parse(t))

	tmpl.Execute(os.Stdout, map[string]string{
		"Name": "xiaoming",
		"Text": "这是一段很长的文本内容需要截断",
	})
}

输出：

XIAOMING 
这是一段很长的文...
1 + 2 = 3

注意：

• 自定义函数必须在 Parse 之前用 Funcs 注册。
• 函数只能返回一个值或 (值, error)；返回 error 时，模板执行会中止并报错。
• 函数名是模板里用的名字，可以和 Go 函数名不同。

八、错误处理

Parse 和 Execute 都可能出错，生产代码必须处理。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

tmpl, err := template.New("x").Parse("{{ .NotExist }}")
if err != nil {
	// 解析错误：语法问题
	log.Fatal(err)
}

err = tmpl.Execute(os.Stdout, map[string]string{"Name": "x"})
if err != nil {
	// 执行错误：字段不存在
	log.Fatal(err)
}

用 template.Must 可以在出错时直接 panic，适合初始化阶段：

1

tmpl := template.Must(template.New("x").Parse("..."))

规则：启动时加载模板用 Must，运行时 Execute 用 if err != nil。

九、text/template vs html/template

规则：

• 生成 HTML → 用 html/template
• 生成 Prompt、配置文件、代码 → 用 text/template

它们的模板语法完全一致，只是转义策略不同。

十、完整可运行示例：Prompt 模板引擎

把上面所有知识点串起来，做一个 Prompt 工程里常见的例子。

目录结构

.
├── main.go
├── config.json
└── prompts/
    └── classify.tmpl

config.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "role": "文本情感分类助手",
  "labels": ["正面", "负面", "中性"],
  "style": "简洁",
  "examples": [
    {"Input": "这家餐厅很棒", "Output": "正面"},
    {"Input": "太失望了", "Output": "负面"},
    {"Input": "今天天气不错", "Output": "中性"}
  ]
}

prompts/classify.tmpl

你是一个{{ .Role }}。请对用户输入的文本进行分类。

{{- if .Labels }}
可选标签：{{ range $i, $l := .Labels }}{{ if $i }}、{{ end }}{{ $l }}{{ end }}
{{- end }}

风格要求：{{ .Style }}

{{- if .Examples }}
示例：
{{- range .Examples }}
输入：{{ .Input }}
输出：{{ .Output }}
{{- end }}
{{- end }}

输入：{{ .Input }}
输出：

main.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"
	"text/template"
)

type Example struct {
	Input  string `json:"input"`
	Output string `json:"output"`
}

type Config struct {
	Role     string    `json:"role"`
	Labels   []string  `json:"labels"`
	Style    string    `json:"style"`
	Examples []Example `json:"examples"`
}

type PromptData struct {
	Role     string
	Labels   []string
	Style    string
	Examples []Example
	Input    string
}

func main() {
	// 1. 读取配置
	cfgBytes, err := os.ReadFile("config.json")
	if err != nil {
		panic(err)
	}
	var cfg Config
	if err := json.Unmarshal(cfgBytes, &cfg); err != nil {
		panic(err)
	}

	// 2. 加载模板
	tmpl := template.Must(template.ParseFiles("prompts/classify.tmpl"))

	// 3. 渲染
	data := PromptData{
		Role:     cfg.Role,
		Labels:   cfg.Labels,
		Style:    cfg.Style,
		Examples: cfg.Examples,
		Input:    "Go 语言的并发模型非常优雅，我很喜欢。",
	}

	var sb strings.Builder
	if err := tmpl.Execute(&sb, data); err != nil {
		panic(err)
	}

	fmt.Println(sb.String())
}

运行

1

go run main.go

输出

你是一个文本情感分类助手。请对用户输入的文本进行分类。

可选标签：正面、负面、中性

风格要求：简洁

示例：
输入：这家餐厅很棒
输出：正面
输入：太失望了
输出：负面
输入：今天天气不错
输出：中性

输入：Go 语言的并发模型非常优雅，我很喜欢。
输出：

这个例子覆盖了：

• struct 作为数据
• if 条件
• range 循环
• 嵌套 if + range
• $i 索引变量
• 空白控制 {{- / -}}
• 从文件加载模板

十一、常见坑与最佳实践