解析：顺序表插入需移动后续元素，平均和最坏时间复杂度均为 O (n)，故 A 错误、C 正确；单链表已知头指针时，需遍历找到第 i-1 个元素（前驱），时间复杂度 O (n)，B 错误；已知第 i 个元素指针时，仍需遍历找前驱（单链表无法反向访问），时间复杂度 O (n)，但 “已知前驱指针” 时才为 O (1)，D 表述场景与结论不匹配，错误。

解析：栈遵循 “先进后出” 原则。A 对应 “push1→pop1，push2→pop2，push3→pop3，push4→pop4”；B 对应 “push1→push2→push3→push4→pop4→pop3→pop2→pop1”；C 对应 “push1→push2→pop2→pop1，push3→push4→pop4→pop3”；D 中，push1-4 后 pop4，栈内剩余 1,2,3（栈顶为 3），需先 pop3 才能 pop2，无法直接 pop2 后再 pop3，故 D 不可能。

解析：A 是队列判空条件（空队列时 front=rear）；C 仅表示 rear 到达数组尾端，此时队列可能仍有空闲位置（如 front>0），并非真满；D 逻辑错误，无法区分满与空；为避免 “假满”（rear=M-1 但 front>0），采用 “预留一个空闲位置” 的设计，当 (rear+1)% M == front 时，队列满（此时队列含 M-1 个元素），B 正确。

解析：后序遍历最后一个元素为根节点（A）；中序遍历中 A 左侧为左子树（DBE），右侧为右子树（FC）。后序左子树序列为 DEB，根为 B；中序 B 左侧为 D（左孩子），右侧为 E（右孩子），故左子树前序为 BDE。后序右子树序列为 FC，根为 C；中序 C 左侧为 F（左孩子），故右子树前序为 CF。整体前序遍历为 A→B→D→E→C→F，即 ABDECF，A 正确。

解析：插入 60 后，50 的右孩子为 60，节点 40 的右子树高度为 2（50、60），左子树高度 0；节点 30 的右子树高度为 3（40、50、60），左子树高度 1（20），失衡点为 30。AVL 树失衡类型由 “失衡点→失衡侧孩子→插入侧” 决定：失衡点 30 的失衡侧为右（右子树更高），右孩子 40 的插入侧也为右（60 插入 40 的右子树），属于 “右 - 右失衡”，需进行 RR 旋转（以失衡点 30 为轴右旋，使 40 成为新根，30 成为 40 的左孩子），B 正确。

解析：哈夫曼树构造规则为 “每次选两个最小权值合并”：①5+6=11（新权值）；②7+8=15（新权值）；③9+11=20（新权值）；④15+20=35（根权值）。最终哈夫曼树中，叶子节点 5、6 的深度为 3（路径：根 35→20→11→5/6），叶子节点 7、8、9 的深度为 2（路径：根 35→15→7/8，根 35→20→9）。WPL=5×3+6×3+7×2+8×2+9×2=15+18+14+16+18=81，B 正确。

解析：DFS 需沿当前顶点的邻接顶点深度遍历，回溯后再访问其他邻接顶点。A：1→2（邻接）→4（2 的邻接）→回溯 1→3（邻接）→5（3 的邻接）；B：1→3（邻接）→5（3 的邻接）→回溯 1→2（邻接）→4（2 的邻接）；D：1→3（邻接）→回溯 1→2（邻接）→4（2 的邻接）→回溯 2→回溯 1→3→5（3 的邻接）；C 中 1→2 后，2 的邻接顶点仅 1 和 4，无 3，无法直接从 2 跳至 3，故 C 不可能。

解析：迪杰斯特拉算法步骤（dist 数组存储源点到各顶点距离，初始 dist=[0,∞,∞,∞]）：①选 V0（dist=0），更新 dist [1]=0+2=2，dist [2]=0+5=5；②选 V1（dist=2），更新 dist [2]=2+1=3（小于原 5），dist [3]=2+4=6；③选 V2（dist=3），更新 dist [3]=3+1=4（小于原 6）；④选 V3（dist=4），算法结束。V0 到 V3 的最短路径为 V0→V1→V2→V3，长度 4，B 正确。

解析：计算各关键字的哈希地址及查找次数（冲突时线性探测，查找次数 = 冲突次数 + 1）：①14：H=14%7=0（无冲突，1 次）；②23：H=23%7=2（无冲突，1 次）；③9：H=9%7=2（冲突→3，2 次）；④30：H=30%7=2（冲突→3 冲突→4，3 次）；⑤12：H=12%7=5（无冲突，1 次）；⑥6：H=6%7=6（无冲突，1 次）；⑦18：H=18%7=4（冲突→5 冲突→6 冲突→0 冲突→1，5 次）。ASL=(1+1+2+3+1+1+5)/7=14/7=2，B 正确。

解析：各算法特性：A. 冒泡排序（稳定，最坏 O (n²)，相邻元素交换，相等元素不交换）；B. 直接插入排序（稳定，最坏 O (n²)，插入时不跨越相等元素）；C. 快速排序（不稳定，最坏 O (n²)，待排序序列有序时，基准元素划分极端不均，且交换可能导致相等元素相对位置变化）；D. 归并排序（稳定，最坏 O (nlogn)，分治合并时保持相等元素顺序）。故 C 正确。

解析：二叉排序树（BST）特性为 “左子树关键字 < 根，右子树关键字 > 根”。插入序列构造的 BST 结构：根 50（深度 1，查找 1 次）；左子树根 30（深度 2，1 次），30 左 20（深度 3，1 次）、右 40（深度 3，1 次）；右子树根 70（深度 2，1 次），70 左 60（深度 3，1 次）、右 80（深度 3，1 次）。总查找次数 = 1×1 + 2×2 + 4×3=1+4+12=17。ASL = 总查找次数 / 关键字个数 = 17/7，B 正确。

解析：1. 对阶：Y 阶码 0010 比 X 阶码 0011 小 1，将 Y 尾数右移 1 位（补码右移高位补符号位 1），Y 变为阶码 0011，尾数 11101100；2. 尾数相加：X 尾数 00110100 + Y 尾数 11101100 = 00100000（双符号位 00，无进位）；3. 判断规格化：补码浮点数规格化条件为 “尾数双符号位不同，且最高数值位为 1”，结果尾数 00100000 满足（双符号位 00，最高数值位 1），属于规格化；4. 判断溢出：阶码双符号位始终为 00，无溢出。综上选 A。

解析： 1. 核心公式推导（串行访问逻辑） 串行访问的本质是 “从发起访问到获取数据的总耗时”，需考虑各级访问的必然消耗（即使不命中，前一级的访问时间已产生），因此平均访问时间公式为： T_avg = T1 + (1-H1)×T2 + (1-H1)×(1-H2)×Tm T1：L1 访问时间（无论命中与否，均需消耗）； (1-H1)：L1 不命中率，此时需额外消耗 L2 访问时间 T2； (1-H1)×(1-H2)：L1、L2 均不命中率，此时需再额外消耗主存访问时间 Tm。 2. 代入数据计算 已知参数：T1=1ns，H1=78%（则 1-H1=22%=0.22）；T2=10ns，H2=75%（则 1-H2=25%=0.25）；Tm=140ns。 分步计算： ① L1 基础访问时间：1ns； ② L1 不命中时的 L2 额外耗时：0.22×10 = 2.2ns； ③ L1、L2 均不命中时的主存额外耗时：0.22×0.25×140 = 7.7ns； ④ 总平均访问时间：1 + 2.2 + 7.7 = 10.9ns。 3. 选项判断 计算结果为 10.9ns，对应选项 B。

解析： 要解决相对寻址的地址计算问题，需紧扣 **“相对寻址中，PC 取值为‘下一条指令地址’”** 这一核心规则（计算机体系结构通用逻辑，即 CPU 执行当前指令时，PC 已自动递增指令长度，指向待取指的下一条指令），具体步骤如下： 第一步：计算 “下一条指令地址” 指令字长为 24 位，换算为字节数：24 位 ÷ 8 位 / 字节 = 3 字节。 当前 PC 指向当前指令地址（0x123456），因此下一条指令地址 = 当前 PC 值 + 指令字节数 = 0x123456 + 3 = 0x123459。 第二步：计算 PC 的目标地址 相对寻址的目标地址 = 下一条指令地址（即相对寻址的 PC 基准值） + 位移量（disp，补码形式）。 题干中 disp=0x0005（16 位补码，正数，十进制值为 5），因此： 目标地址 = 0x123459 + 0x0005 = 0x12345E。 选项分析 A 选项（0x123456）：仅当前指令地址，未加指令长度和位移量，错误； B 选项（0x12345C）：若误将指令字长算为 2 字节（24 位≠2 字节），则下一条指令地址为 0x123458，加 0x0005 得 0x12345D，仍不匹配，错误； C 选项（0x12345E）：与上述计算结果一致，正确； D 选项（0x123464）：若误将位移量算为 0x000F（十进制 15），则 0x123459+0x000F=0x123468，仍不匹配，错误。

解析： 要计算流水线加速比，需遵循“**瓶颈段决定流水线周期→计算总时间→代入加速比公式**”的核心逻辑，步骤如下： 1. 确定流水线周期（核心：找瓶颈段） 流水线的周期由**最长段（瓶颈段）的执行时间**决定（因各段串行流转，最慢的段会限制整体速率）。 本题中4段时间分别为2ns、4ns、1ns、3ns，最长段为**段2（4ns）**，因此流水线周期 \( T = 4\,\text{ns} \)。 2. 计算两类执行方式的总时间 - **非流水线总时间**：非流水线执行时，每条任务需完整串行经过4段，总时间=任务数×单任务非流水线周期。 代入数据：\( T_{\text{非流水线}} = 100 \times 10 = 1000\,\text{ns} \)。 - **流水线总时间**：流水线执行时，首条任务需经过全部4段（耗时\( 4 \times T \)），后续每条任务仅需1个流水线周期（因各段并行工作），总时间公式为： \( T_{\text{流水线}} = (\text{段数} + \text{任务数} - 1) \times \text{流水线周期} \) 代入数据：\( T_{\text{流水线}} = (4 + 100 - 1) \times 4 = 103 \times 4 = 412\,\text{ns} \)。 （注：当任务数远大于段数时，可简化为\( T_{\text{流水线}} \approx \text{任务数} \times \text{流水线周期} \)，本题简化后为\( 100 \times 4 = 400\,\text{ns} \)，误差极小，不影响结果判断。） 3. 计算加速比 加速比定义为“非流水线总时间与流水线总时间的比值”，公式为： \( \text{加速比} = \frac{T_{\text{非流水线}}}{T_{\text{流水线}}} \) 代入数据：\( \text{加速比} \approx \frac{1000}{412} \approx 2.43 \)，因计算中忽略微小误差，结果约为**2.5**。

解析：1. 8421 BCD 码中，5=0101，6=0110；2. 二进制相加：0101 + 0110 = 1011（十进制 11）；3. BCD 码校正规则：结果 > 9（1001）或有进位时，需加 6（0110）校正；4. 校正计算：1011 + 0110 = 10001，其中高 4 位 0001 为进位（表示 1 个十），低 4 位 0001 为个位，即校正后结果为 0001 0001（十进制 11），且执行了加 6 校正。综上选 B。

解析：1. 确定扩展需求：目标存储器 16K×16 位，芯片 1K×8 位（原题应为 4K×8 位，修正后）；2. 字扩展（增加地址空间）：目标字数 16K，芯片字数 4K，需字扩展倍数 = 16K/4K=4（即需 4 组芯片，每组对应不同地址范围）；3. 位扩展（增加数据位数）：目标位数 16 位，芯片位数 8 位，需位扩展倍数 = 16/8=2（即每组需 2 片芯片并联，分别提供高 8 位和低 8 位数据）；4. 总芯片数 = 字扩展倍数 × 位扩展倍数 = 4×2=8 片。核心考点：字扩展解决 “地址不够”（需地址线选择芯片组），位扩展解决 “位数不够”（需数据线并联），两者结合时总片数为两者乘积。综上选 C。

解析：取指周期的核心任务是 “从内存取出指令并送入指令寄存器 IR”，典型微操作序列为：1. PC（程序计数器，存当前指令地址）→ MAR（存储器地址寄存器），送地址；2. 控制内存读操作（如 Read 信号有效），将指令从内存读出至 MDR（存储器数据寄存器）；3. MDR → IR，将指令送入 IR；4. PC + 1 → PC，为取下一条指令做准备。选项 C“IR（操作数地址字段）→ MAR” 是 “执行周期” 的微操作（用于读取操作数地址），不属于取指周期。综上选 C。

解析：I/O 编址方式分为独立编址（I/O 映射）和统一编址（内存映射）：1. 独立编址特点：I/O 地址空间与内存独立（不重叠），需专用 I/O 指令（如 IN/OUT），地址译码电路独立；2. 统一编址特点：I/O 地址空间与内存重叠，用访存指令访问 I/O，可复用内存译码电路。选项 A、B、D 均为统一编址特点，选项 C 为独立编址特点。综上选 C。

解析：浮点数精度取决于 “尾数可表示的数值密集程度”：1. 基数 r，尾数 n 位（原码），可表示的最小非零正数为 r^(-(n-1))；2. 基数越小，最小非零正数越小，数值间隔越密，精度越高。基数 2 时，最小非零正数 = 2^(-23)；基数 4 时，最小非零正数 = 4^(-23)=2^(-46)？错误，重新计算：尾数位数 24 位（含符号位），数值位 23 位。基数 r 的浮点数，相邻两个可表示数的间隔约为 r^(阶码) × r^(-(n-1))（n 为数值位）。基数 2 时间隔 = 2^ 阶码 × 2^(-23)，基数 4 时 = 4^ 阶码 ×4^(-23)=2^(2 阶码) ×2^(-46)。当阶码相同时（如阶码 = 0），基数 2 的间隔 = 2^(-23)，基数 4 的间隔 = 2^(-46)，看似基数 4 间隔更小？实际错误：基数 4 的尾数每增加 1，数值增加 4^k（k 为尾数位置），而基数 2 增加 2^k。例如，基数 2 的 23 位数值位可表示 2^23 个不同小数，基数 4 的 23 位数值位可表示 4^23=2^46 个不同小数，但 “精度” 指 “表示小数的细腻程度”，基数 2 的相邻数间隔均匀且更小（如 0.001 和 0.010 间隔 0.001，基数 4 的 0.01 和 0.10 间隔 0.03）。核心结论：相同尾数位数下，基数越小，精度越高。综上选 A。

解析：PSW 的核心标志位包括：1. 运算结果标志：进位标志 CF（无符号数溢出）、零标志 ZF（结果为 0）、符号标志 SF（结果符号）、溢出标志 OF（有符号数溢出）、奇偶标志 PF（结果中 1 的个数奇偶）；2. 控制标志：中断允许标志 IF（允许 / 禁止可屏蔽中断）、陷阱标志 TF（单步执行）、方向标志 DF（串操作方向）。选项 D“指令地址标志（IAF）” 并非标准 PSW 标志，指令地址由程序计数器 PC 保存，不属于 PSW。综上选 D。

解析：数据冒险分为三类：1. RAW（写后读）：后指令读前指令未写的寄存器。指令 2 的 ID 段读 R1，指令 1 的 EX 段才写 R1，存在 RAW；2. WAR（读后写）：后指令写前指令未读的寄存器。指令 2 的 ID 段读 R1，指令 3 的 EX 段写 R1，若指令 3 提前执行，可能导致指令 2 读错 R1，但本题流水线为 IF→ID→EX，指令 3 的 EX 段在指令 2 的 ID 段之后，无 WAR；3. WAW（写后写）：两指令写同一寄存器，且前指令未写后指令已写。指令 1 的 EX 段写 R1，指令 3 的 EX 段也写 R1，若指令 3 的 EX 段早于指令 1 的 EX 段（如流水线乱序），会导致 R1 被指令 3 覆盖，存在 WAW。综上，存在 RAW 和 WAW 冒险，选 C。

答案为 C。解析：1. 计算各算法平均周转时间：A 选项 FCFS：执行顺序 P1→P2→P3，完成时间分别为 4、5、6，周转时间 4、4、4，平均 (4+4+4)/3≈4.0；B 选项非抢占式 SJF：P1 先运行，完成后执行 P2、P3，完成时间 4、5、6，周转时间 4、4、4，平均≈4.0；C 选项抢占式 SJF：执行顺序 P1 (0-1)→P2 (1-2)→P3 (2-3)→P1 (3-7)，完成时间 7、2、3，周转时间 7、1、1，平均 (7+1+1)/3≈3.0；D 选项静态优先级：执行顺序 P1→P2→P3，与 FCFS 结果一致，平均≈4.0。2. 结论：抢占式 SJF 平均周转时间最小，故 C 正确。

答案为 A。解析： 判断死锁风险的核心是银行家算法—— 即系统是否存在 “安全序列”（按该序列分配资源，所有进程可依次完成并释放资源），而非单纯看 “剩余资源能否直接满足某一进程” 或 “是否存在潜在循环”。 第一步：计算核心参数 总资源数 m=8，已分配资源总数 = 3（P1）+2（P2）+2（P3）=7，因此剩余资源 available=8-7=1。 各进程剩余需求（最大需求 - 已分配）：P1=4-3=1，P2=5-2=3，P3=6-2=4。 第二步：推导安全序列 安全序列的本质是 “找到一个进程，其剩余需求≤当前剩余资源，让它完成后释放资源，再用释放的资源满足下一个进程”，循环此过程直到所有进程完成： 初始剩余资源 available=1，仅能满足 P1 的剩余需求（1），分配给 P1； P1 获得资源后，已分配达到最大需求（3+1=4），正常完成，释放全部 4 个资源（已分配的 3 个 + 刚获取的 1 个），此时 available=4； 剩余资源 available=4，可满足 P3 的剩余需求（4），分配给 P3； P3 获得资源后，已分配达到最大需求（2+4=6），正常完成，释放全部 6 个资源，此时 available=4-4+6=6； 剩余资源 available=6，可满足 P2 的剩余需求（3），分配给 P2； P2 完成后释放全部资源，系统无资源占用，所有进程均完成。 综上，存在明确的安全序列 P1→P3→P2，系统无死锁风险。 第三步：分析各选项对错 A 正确：剩余资源虽不能直接满足所有进程，但通过 “先满足 P1→释放资源→满足 P3→释放资源→满足 P2” 的分配逻辑，可满足所有进程的最终需求（核心是安全序列存在）。 B 错误：“循环等待” 是死锁的必要条件（死锁必须满足），但不是 “充分条件”（有潜在循环不代表一定死锁）。本题中 P2 与 P3 的依赖可通过 P1 释放的资源打破，未形成 “不可打破的循环等待”。 C 错误：首先，“n*(k-1)≥m” 是错误公式（k 需统一为 “所有进程的最大需求”，但本题 P1/P2/P3 最大需求不同，公式不适用）；其次，正确的 “资源充足性公式” 是 “∑(各进程最大需求 - 1)+1 ≤ m → 无死锁风险”，本题计算为 (3+4+5)+1=13>8，仅说明 “存在死锁可能性”，而非 “必然存在死锁”，且 C 的公式本身错误，故不选。 D 错误：“进程已获取部分资源” 是死锁的 “持有并等待” 必要条件，而非 “无死锁” 的依据（很多死锁场景中进程也已获取部分资源），逻辑颠倒，故不选。

答案为 B。解析：1. 页面大小与地址结构：4KB=2¹²B，故页内偏移占 12 位（十六进制 3 位），剩余 32-12=20 位为页号（十六进制 5 位）。2. 逻辑地址转换：十六进制 0x123456 共 6 位，按 “页号 + 页内偏移” 拆分，后 3 位（0x456）为页内偏移，前 6-3=3 位（0x123）为页号。3. 选项判断：A（0x12）仅取前 2 位，C（0x1234）取前 4 位，D（0x2345）取中间 4 位，均错误；B（0x123）正确。

答案为 D。解析：

1. 标准 Clock 算法（仅使用位）核心规则 维护一个循环指针，指向当前待检查的内存块（初始指针ptr=0，按内存块顺序循环移动）； 置换触发时，从指针位置开始依次扫描： 若当前页面 “使用位 = 1”：给页面 “第二次机会”，将使用位置为 0，指针下移（ptr=(ptr+1)%块数）； 若当前页面 “使用位 = 0”：直接置换该页面，装入新页面并设 “使用位 = 1”，指针下移； 若首次扫描全为 “使用位 = 1”（一圈后全被置 0），则从指针位置重新扫描，置换首个 “使用位 = 0” 的页面； 页面命中时：将该页面的 “使用位重置为 1”，指针不移动（部分教材允许指针移动，此处按主流 “命中不移动指针” 逻辑模拟，结果一致）。

2. 缺页过程分步模拟（内存块 B0、B1、B2，fault=0为缺页次数）

| 步骤 | 访问页面 | 内存块状态（B0,B1,B2,B3） | 使用位 | 指针ptr | 操作（缺页/命中） | fault |

|------|----------|---------------------------|--------|---------|--------------------|-------|

| 1 | 2 | 空→装入2到B0 | (1,-,-,-) | 1 | 缺页 | 1 | | 2 | 3 | 装入3到B1 | (1,1,-,-) | 2 | 缺页 | 2 |

| 3 | 1 | 装入1到B2 | (1,1,1,-) | 3 | 缺页 | 3 | | 4 | 4 | 装入4到B3 | (1,1,1,1) | 0 | 缺页 | 4 |

| 5 | 2 | 命中2，use=1重置为1 | (1,1,1,1) | 0 | 命中 | 4 | | 6 | 5 | 1. 扫B0（1→0）ptr=1；
2. 扫B1（1→0）ptr=2；
3. 扫B2（1→0）ptr=3；
4. 扫B3（1→0）ptr=0；5. 重扫B0（0），置换为5 | (1,0,0,0) | 1 | 缺页 | 5 |

| 7 | 3 | 1. 扫B1（0），置换为3 | (1,1,0,0) | 2 | 缺页 | 6 |

| 8 | 2 | 命中2，use=1重置为1 | (1,1,0,0) | 2 | 命中 | 6 |

| 9 | 1 | 1. 扫B2（0），置换为1 | (1,1,1,0) | 3 | 缺页 | 7 |

| 10 | 6 | 1. 扫B3（0），置换为6 | (1,1,1,1) | 0 | 缺页 | 8 |

| 11 | 5 | 命中5，use=1重置为1 | (1,1,1,1) | 0 | 命中 | 8 |

| 12 | 3 | 命中3，use=1重置为1 | (1,1,1,1) | 0 | 命中 | 8 |

3. 结论 总缺页次数为9 次，对应选项 D。

答案为 B。解析：1. 信号量作用：①mutex（互斥信号量）：保证缓冲区操作互斥，初值为 1（任一时刻仅一个进程操作缓冲区）；②empty（空缓冲区信号量）：表示空缓冲区数量，初始缓冲区全空，初值为缓冲区大小 5；③full（满缓冲区信号量）：表示满缓冲区数量，初始无数据，初值为 0。2. 选项判断：A（mutex=5、empty=1）、C（empty=0、full=5）、D（mutex=5、empty=0、full=1）均错误，B 符合信号量初值规则，故 B 正确。

答案为 B。解析：1. 索引项与盘块数量关系：索引项大小 4B，盘块大小 1KB=1024B，故一个间接索引块可存储 1024/4=256 个索引项（即指向 256 个数据块）。2. 最大文件大小计算：①直接索引：10 个数据块，大小 10×1KB；②一级间接索引：256 个数据块，大小 256×1KB；③二级间接索引：256×256 个数据块，大小 256²×1KB；总大小 =(10+256+256²)×1KB。3. 选项判断：A 未计算二级间接索引，C 将索引项数量算为 512（误按索引项 2B 计算），D 同时错误计算一级和二级间接索引数量，均错误；B 正确。

答案为 B。解析：1. 各 I/O 控制方式特点：A 错误，程序查询方式 CPU 需 “忙等” 查询设备状态，I/O 效率最低；B 正确，中断驱动方式中，CPU 启动 I/O 后可执行其他任务，仅在设备完成传送后处理中断，实现 CPU 与 I/O 并行；C 错误，DMA 方式通过 DMA 控制器成块传送数据，无需 CPU 逐字节控制，大幅减少 CPU 干预；D 错误，通道方式需 CPU 先初始化通道程序（告知通道传送参数），通道执行时才独立于 CPU。2. 结论：B 描述正确。

答案为 C。解析：1. 进程状态转换规则：①运行态→就绪态：时间片用完或有更高优先级进程进入就绪态，CPU 被抢占，转换可能；②运行态→阻塞态：进程等待资源（如 I/O）或事件（如信号），主动放弃 CPU，转换可能；③就绪态→阻塞态：就绪态进程已具备运行条件（仅缺 CPU），无法因 “等待资源 / 事件” 进入阻塞态，转换不可能；④阻塞态→就绪态：进程等待的资源 / 事件完成，被唤醒后进入就绪态，转换可能。2. 选项判断：C 为不可能转换，故 C 正确。

答案：A

根据银行家算法，系统应检查批准P1的请求（R1:0、R2:1）后是否处于安全状态。当前系统剩余资源为R1:1、R2:1，P1已分配R1:1、R2:1，最大需求R1:2、R2:2；P2已分配R1:1、R2:0，最大需求R1:2、R2:1。

批准请求后，系统剩余资源变为R1:1、R2:0。P1的已分配资源变为R1:1、R2:2，因此其剩余需求为R1:1、R2:0；P2的剩余需求为R1:1、R2:1。

此时，系统可用资源R1:1、R2:0可以满足P1的剩余需求（R1:1、R2:0），因此P1可以完成并释放所有资源（R1:1、R2:2），使系统可用资源变为R1:2、R2:2。之后，P2的剩余需求（R1:1、R2:1）可以得到满足，P2也能完成。因此，存在安全序列（P1然后P2），系统无死锁风险。

选项A正确，因为批准后系统无死锁风险。选项C虽然也建议批准，但理由不充分（仅基于请求未超过最大需求），而银行家算法的关键依据是系统安全状态。选项B和D错误，因为批准后系统安全，且P2的需求最终能满足。

答案为 B。解析：1. 页面大小与内存性能关系：①页内碎片：页面大小越大，单个页面未利用的空间（页内碎片）越大（如进程大小 5KB，4KB 页面产生 3KB 碎片，8KB 页面产生 3KB 碎片，此处需注意：进程大小固定时，页面超过进程大小后碎片不变，但整体趋势是页面越大碎片越大）；②缺页率：页面越大，进程所需页面数越少，访问时缺页概率通常越低（除非页面过大导致 “一页包含多个不常用数据”，但常规场景下缺页率随页面增大而降低）。2. 选项判断：A（页内碎片越小）、C（页内碎片越大）、D（缺页率越低）均错误；B 符合页面大小对内存性能的影响规律，故 B 正确。

答案为 D。解析：HTTP 协议是超文本传输协议，用于 Web 数据交互，属于应用层协议，而非数据链路层协议。A 选项，OSI 应用层与 TCP/IP 应用层功能一致，FTP（文件传输协议）属于应用层，描述正确；B 选项，TCP（传输控制协议）负责端到端可靠传输，属于传输层，描述正确；C 选项，IP（网际协议）负责路由选择和跨网络数据传输，属于网络层（TCP/IP 网际层），描述正确。

答案为 B。解析：TCP 快重传机制触发条件是收到 3 个重复确认，此时判定为个别报文丢失而非网络拥塞，故不执行 “慢开始”（cwnd 不重置为 1），而是将 cwnd 重置为当前 ssthresh，随后进入 “快恢复” 阶段，cwnd 按线性规律增长（每次 RTT 增加 1 个 MSS）。A 选项是 “超时重传” 后的变化规律，C 选项不符合拥塞控制逻辑，D 选项描述的变化方式不存在于 TCP 拥塞控制中。

答案为 A。解析：子网掩码 255.255.255.192（二进制为 11111111.11111111.11111111.11000000），可知子网位为 2 位，子网块大小 = 2^(8-2)=64。将 IP 地址 192.168.1.125 的主机位（最后 8 位）与子网掩码按位与，得 192.168.1.64（125 的二进制为 01111101，与 11000000 按位与为 01000000，即 64），故网络地址为 192.168.1.64。可用主机数 = 子网内总主机数 - 2（网络地址和广播地址）=2^6 -2=62。B 选项网络地址计算错误，C 选项未减去网络 / 广播地址，D 选项子网块大小计算错误。

答案为 C。解析：ARP 协议基于广播机制工作，而路由器会隔绝广播域，因此 ARP 无法跨路由器解析不同网段主机的 MAC 地址（跨网段通信需通过路由器转发，主机仅需知道路由器的 MAC 地址）。A 选项是 ARP 的核心功能，描述正确；B 选项，ARP 请求需让同一网段所有主机接收，故为广播，ARP 响应仅需发送给请求主机，故为单播，描述正确；D 选项，主机发送 ARP 请求时，会临时缓存目标 IP 与自身 MAC 的映射，待收到响应后更新为目标 IP 与目标 MAC 的映射，描述正确。

答案为 B。解析：HTTP/1.1 引入流水线机制，允许客户端在收到前一个请求的响应前，向服务器发送多个请求，提升通信效率，描述正确。A 选项，HTTP/1.0 默认使用短连接，长连接需通过 Keep-Alive 头字段手动开启，描述错误；C 选项，HTTP/2 强制使用加密传输（基于 TLS），且核心改进是多路复用（而非仅提升速率），描述错误；D 选项，HTTPS 的加密层基于 TLS 协议（SSLv3 已因安全漏洞被淘汰），描述错误。

答案为 B。解析：以太网交换机基于 MAC 地址转发数据，每个端口对应一个独立的冲突域（避免端口间数据冲突），但交换机不隔绝广播，所有端口属于同一广播域，符合 “分割冲突域、不分割广播域” 的特征。A 选项，集线器是共享设备，所有端口属于同一冲突域和广播域，无法分割冲突域；C 选项，路由器每个端口对应一个独立的冲突域和广播域，既能分割冲突域也能分割广播域；D 选项，网桥虽能分割冲突域但不分割广播域，但 408 统考中更侧重以太网交换机（网桥的升级设备）的考察，且题目选项中交换机为更典型答案。

答案：C

根据IP分片规则，每个分片的数据部分长度必须是8字节的倍数（除了最后一个分片，但本例中原始数据部分1480字节是8的倍数，因此所有分片数据部分都应为8的倍数）。MTU为1000字节，IP头占20字节，因此每个分片的最大数据部分长度为1000 - 20 = 980字节。但980不是8的倍数，因此实际最大数据部分长度应取8的倍数，即976字节。然而，选项中没有976字节和504字节的组合。

选项分析：

• A: 1片，1480字节 — 总长度1500字节超过MTU 1000字节，必须分片，无效。

• B: 2片，980字节和500字节 — 980和500都不是8的倍数，无效。

• D: 3片，980字节、480字节和20字节 — 980和20不是8的倍数，无效。

• C: 2片，960字节和520字节 — 960和520都是8的倍数（960 ÷ 8 = 120, 520 ÷ 8 = 65），且总和为1480字节，符合要求。每个分片总长度不超过MTU：第一分片960 + 20 = 980字节 ≤ 1000字节，第二分片520 + 20 = 540字节 ≤ 1000字节。

因此，正确选项为C。

答案为 C。解析：GBN 协议是累计确认的滑动窗口协议，为避免接收端乱序，接收窗口大小固定为 1（仅接收序号连续的帧）；发送端可连续发送帧，发送窗口大小 > 1（最大为 2^n -1，n 为序号位数），符合 “发送窗口> 1，接收窗口 = 1” 的特征。A 选项是停止 - 等待协议的窗口特征；B 选项无对应滑动窗口协议；D 选项是选择重传（SR）协议的窗口特征（发送窗口 = 接收窗口 > 1，且≤2^(n-1)）。

(1) 算法的基本设计思想
算法基于**递归前序遍历**实现，核心思路是“路径记录+回溯”，具体如下：
1. **路径记录**：前序遍历首先访问根节点，将当前节点的权值存入临时路径数组`path`，并更新当前路径长度`pathLen`。
2. **路径校验**：计算当前路径中所有节点的权值之和，若和等于k，则打印当前路径（从根到当前节点）；若和小于k，继续遍历子树（因节点权值可能为负，和大于k时仍需遍历子树，避免遗漏负权值导致和再次等于k的情况）。
3. **递归遍历**：递归遍历当前节点的左子树，再递归遍历当前节点的右子树（遵循前序遍历“根-左-右”顺序）。
4. **回溯操作**：递归返回前（即离开当前节点时），需将当前节点从临时路径数组中“移除”（通过减少`pathLen`实现，无需显式删除数组元素，因后续节点会覆盖当前位置），确保回溯到父节点时路径数组仅包含父节点及其祖先节点。
5. **终止条件**：当遍历到空节点（T==NULL）时，直接返回，结束当前递归分支。

(2) C语言算法实现
```c
#include <stdio.h> // 用于printf函数

// 节点结构定义（题目已给出，此处为代码完整性重复）
typedef struct BiNode {
    int val;
    struct BiNode *lchild;
    struct BiNode *rchild;
} BiNode, *BiTree;

// 辅助函数：计算当前路径的权值之和（可选，也可在主函数中实时累加）
int CalculatePathSum(int *path, int pathLen) {
    int sum = 0;
    for (int i = 0; i < pathLen; i++) {
        sum += path[i];
    }
    return sum;
}

// 主算法函数
void FindValidPaths(BiTree T, int k, int *path, int pathLen) {
    // 终止条件：空节点，直接返回
    if (T == NULL) {
        return;
    }
    
    // 1. 记录当前节点：将当前节点权值存入路径数组，路径长度+1
    path[pathLen] = T->val;
    pathLen++;
    
    // 2. 校验当前路径：若权值和等于k，打印路径
    int currentSum = CalculatePathSum(path, pathLen);
    if (currentSum == k) {
        printf("有效路径：");
        for (int i = 0; i < pathLen; i++) {
            printf("%d ", path[i]);
        }
        printf("\n");
    }
    
    // 3. 递归遍历左子树和右子树（无论sum是否等于k，均需遍历，因节点权值可能为负）
    FindValidPaths(T->lchild, k, path, pathLen); // 遍历左子树
    FindValidPaths(T->rchild, k, path, pathLen); // 遍历右子树
    
    // 4. 回溯操作：路径长度-1（无需修改path数组，后续节点会覆盖当前位置）
    pathLen--;
}

// 初始化调用示例（供参考，非算法必需）
// void InitCall(BiTree T, int k) {
//     int path[100]; // 假设树的高度不超过100，实际应用中可动态分配
//     FindValidPaths(T, k, path, 0);
// }
```

(3) 时间复杂度与空间复杂度
- **时间复杂度**：设二叉树的节点总数为n。算法中每个节点仅被访问一次（前序遍历），每次访问节点时的操作（存路径、计算和、打印）均为O(pathLen)，而`pathLen`最大为树的高度h（最坏情况下为n，即单链树）。因此总时间复杂度为**O(n×h)**，最坏情况下（单链树）为O(n²)，平均情况下（平衡二叉树）为O(n×logn)。
- **空间复杂度**：空间开销主要来自两部分：
  1. 递归调用栈：最大深度为树的高度h，最坏情况下为O(n)；
  2. 临时路径数组`path`：最大长度为树的高度h，最坏情况下为O(n)。
  因此总空间复杂度为**O(h)**，最坏情况下为O(n)，平均情况下为O(logn)。

（1）BST构造与ASL计算
1. BST构造逻辑
二叉排序树（BST）插入规则：新关键字始终作为叶子节点插入，且满足“左子树所有关键字＜根关键字＜右子树所有关键字”。依次插入序列{15, 8, 20, 5, 12, 25, 10, 18}的核心步骤如下：
- 插入15：树空，15成为根节点（深度1）；
- 插入8：8＜15，作为15的左孩子（深度2）；
- 插入20：20＞15，作为15的右孩子（深度2）；
- 插入5：5＜15→5＜8，作为8的左孩子（深度3）；
- 插入12：12＜15→12＞8，作为8的右孩子（深度3）；
- 插入25：25＞15→25＞20，作为20的右孩子（深度3）；
- 插入10：10＜15→10＞8→10＜12，作为12的左孩子（深度4）；
- 插入18：18＞15→18＜20，作为20的左孩子（深度3）。

2. 最终BST结构（文字映射图形）
```
        15（深度1）
       /  \
     8（2） 20（2）
    / \    /  \
  5（3）12（3）18（3）25（3）
       /
     10（4）
```

3. ASL计算
等概率查找时，**ASL = 所有关键字的查找次数之和 / 关键字总数**，其中“查找次数”等于关键字所在节点的深度（根节点深度为1）：
- 各关键字深度与查找次数：15（1）、8（2）、20（2）、5（3）、12（3）、25（3）、10（4）、18（3）；
- 查找次数之和：1 + 2 + 2 + 3 + 3 + 3 + 4 + 3 = 21；
- 关键字总数：8；
- 最终ASL = 21 / 8 = 2.625。

（2）查找关键字18的路径与比较次数
1. 查找路径
遵循BST查找规则（“小于当前节点向左，大于当前节点向右”），查找18的路径为：**15→20→18**。

2. 关键字比较次数
查找过程中需依次与15、20、18进行比较，共3次。

（3）删除关键字20后的BST结构与删除过程
1. 删除节点类型判断
关键字20所在节点为“同时拥有左、右子树的非叶子节点”（左子树以18为根，右子树以25为根），需采用“中序后继替换法”处理（BST删除此类节点的标准方法之一）：选择该节点的**中序后继节点**（右子树中值最小的节点，即右子树最左节点）替换其值，再删除中序后继节点。

2. 中序后继节点确定
20的右子树以25为根，且25无左孩子（左指针为空），因此25是20的中序后继节点。

3. 具体删除步骤
- 步骤1：值替换——将中序后继节点（25）的关键字赋给20所在节点，此时原20节点的关键字更新为25；
- 步骤2：删除后继——原25节点为叶子节点，直接将其父亲节点（现关键字为25的节点）的右指针置空。

4. 删除后的BST结构（文字映射图形）
```
        15（深度1）
       /  \
     8（2） 25（2）
    / \    /
  5（3）12（3）18（3）
       /
     10（4）
```

1) 主存地址 Cache 组号、块内地址位数及 VA 索引位
Cache 组号位数（G）：组数 = Cache 容量 /(相联度 × 块大小)=32KB/(8×64B)=(32×1024)/(512)=64=2⁶ → G=6 位。
块内地址位数（b）：块大小 = 64B=2⁶ → b=6 位。
VA 中的 Cache 索引：VA 结构为 “虚拟页号（VA31~VA12，20 位）+ 页内偏移（VA11~VA0，12 位）”，且页内偏移 = 组号（VA11~VA6）+ 块内地址（VA5~VA0） → Cache 索引为 VA11~VA6（6 位）。
2) a [512] 的 VA 及对应 Cache 组号
a [512] 的 VA：int 占 4B，a [i] 的 VA = 起始 VA + i×4=01C00030H + 512×4=01C00030H + 00000800H=01C00830H。
a [512] 所在主存块的 Cache 组号：主存块的页内偏移 = VA11~VA0=0830H（01C00830H 低 12 位）；组号为页内偏移高 6 位（VA11~VA6）：0830H 转二进制为 0000100000110000，VA11~VA6 为 100000B=32（十进制） → 组号 = 32。
3) a [0] 块内偏移、Cache 缺失率及平均访问时间
a [0] 的块内偏移：块内偏移 = VA5~VA0（低 6 位），a [0] VA=01C00030H，低 6 位 = 30H&3FH=30H=48（十进制） → 偏移量 = 48。
Cache 缺失率：
总访问次数：每个 a [i] 读、写各 1 次，2048 个元素共 2048×2=4096 次；
缺失次数：1 块含 64B/4B=16 个元素，总块数 = 2048/16=128 块，仅首次读每块缺失 1 次 → 缺失次数 = 128；
缺失率 =（128/4096）×100%=3.125%≈3.13%。
平均访问时间：t_avg = 命中时间 + 缺失率 × 缺失损失 = 1 + 3.125%×180=6.625≈6.63（时钟周期）。
4) 数组 a 的页数及缺页次数
数组 a 分布的页数：数组总大小 = 2048×4=8192B=8KB，页大小 4KB → 页数 = 8KB/4KB=2 页（验证：a [0]~a [1023] 属虚拟页 01C00H，a [1024]~a [2047] 属虚拟页 01C01H）。
缺页次数：首次访问 2 个虚拟页时各缺页 1 次，后续访问命中 → 缺页次数 = 2 次。

(1) 第11条指令虚拟地址：0040207C H
解析：
指令的虚拟地址按“前一条指令地址 + 前一条指令字节数”依次推导：
第10条指令地址为00402071H，其机器码为11字节（C7 84 B6 00 10 43 00 78 56 34 12）；
第11条指令地址 = 第10条指令地址 + 11 = 00402071H + 0BH = 0040207C H。

(2) 寻址方式：相对寻址；第2条jmp偏移量：0BH
解析：
1. 寻址方式判断：x86架构中，操作码为EBH（短跳转）和7CH（条件跳转）的指令均采用相对寻址，跳转目标地址由“当前指令的下一条指令地址（PC值） + 带符号偏移量”计算得出。

2. 第2条jmp目标地址推导：
第2条指令地址：00402057H，指令长度为2字节（EB 0B）；
当前PC值（下一条指令地址）= 00402057H + 2 = 00402059H；
已知目标地址为00402064H，偏移量 = 目标地址 - PC值 = 00402064H - 00402059H = 0BH（8位无符号数，此处为正偏移）；
验证：PC值 + 偏移量 = 00402059H + 0BH = 00402064H，与目标地址一致。

(3) ①立即寻址；②逻辑含义：计算数组元素的行内偏移字节数，EA=00431000H + (i*64 + j)*4；③小端方式
解析：
1. 源操作数寻址方式：源操作数为立即数0x12345678，直接包含在指令中，故为立即寻址。

2. 地址计算逻辑与EA公式：
数组a[32][64]为int型（4字节），按“行优先”存储，a[i][j]的地址需先计算“i行的总字节数”+“j列的字节偏移”；
由题干知：esi = i*64（第5条指令），edx = j，故“esi*4 + edx*4 = (i*64 + j)*4”，逻辑含义为“a[i][j]相对于行首a[i][0]的字节偏移量”（i*64为i行的总列数，乘以4字节得行内总偏移）；
有效地址EA = 数组首地址 + 偏移量 = 00431000H + (i*64 + j)*4。

3. 大小端判断：
第10条指令的机器码中，立即数0x12345678对应的字节序列为“78 56 34 12”（机器码后4字节）；
小端方式定义为“低字节数据存低地址，高字节数据存高地址”：指令中低地址字节（78H）对应立即数的低字节（0x78），高地址字节（12H）对应立即数的高字节（0x12），符合小端规则，故计算机M为小端方式。

(4) 会发生Cache缺失
解析：
1. 直接映射Cache地址划分：
主存地址（32位）= 标记位（32-10-6=16位） + 行号（10位，对应1024行） + 块内偏移（6位，对应64字节/行）。

2. 第一次访问地址分析：
第一次执行第10条指令时，访问a[0][0]，其地址 = 00431000H（首地址）；
转换为二进制：00431000H = 0000 0000 0100 0011 0001 0000 0000 0000B；
拆分地址字段：
块内偏移（低6位）：000000B（对应字节0~63中的第0字节）；
行号（中间10位）：0001 0000 00B（即64，对应Cache第64行）；
标记位（高16位）：0000 0000 0100 0011B（即0043H）。

3. 缺失判断：
第一次访问时，Cache所有行均为“空”（无有效数据），Cache第64行中无标记位0043H对应的有效数据，故发生Cache缺失。

（1）不考虑资源约束时的调度计算
关键分析步骤：
1. 时间轴与进程状态变化：
- t=0ms：P1到达（优先级2），无其他进程，开始运行；
- t=3ms：P2到达（优先级1，高于P1），触发抢占，P1暂停（已运行3ms，剩余7ms），P2开始运行；
- t=3+8=11ms：P2运行结束（完成时间11ms），此时就绪队列中为P1（剩余7ms，优先级2）和P3（t=5ms到达，优先级3），选择P1继续运行；
- t=11+7=18ms：P1运行结束（完成时间18ms），就绪队列中仅剩P3，P3开始运行；
- t=18+5=23ms：P3运行结束（完成时间23ms）。

2. 各进程时间计算：
- P1：完成时间=18ms，周转时间=18-0=18ms；
- P2：完成时间=11ms，周转时间=11-3=8ms；
- P3：完成时间=23ms，周转时间=23-5=18ms；
- 平均周转时间=(18+8+18)/3=44/3≈14.67ms。

（2）银行家算法安全状态判断
关键分析步骤：
1. 明确核心矩阵（单位：台）：
- 总资源矩阵Total=(2,1)；
- 已分配矩阵Allocation：P1=(1,0)，P2=(1,1)，P3=(0,0)，即Allocation=[[1,0],[1,1],[0,0]]；
- 需求矩阵Need=资源需求-已分配：P1=(1-1,0-0)=(0,0)，P2=(1-1,1-1)=(0,0)，P3=(1-0,0-0)=(1,0)，即Need=[[0,0],[0,0],[1,0]]；
- 剩余资源矩阵Available=Total-ΣAllocation=(2-(1+1+0),1-(0+1+0))=(0,0)。

2. 安全序列查找：
- 步骤1：检查各进程Need是否≤Available=(0,0)。P1的Need=(0,0)≤(0,0)，P2的Need=(0,0)≤(0,0)，均满足；
- 步骤2：选择P1作为首个完成进程，释放其已分配资源，Available更新为(0+1,0+0)=(1,0)；
- 步骤3：再次检查剩余进程（P2、P3），P2的Need=(0,0)≤(1,0)，选择P2完成，释放资源后Available更新为(1+1,0+1)=(2,1)；
- 步骤4：检查P3的Need=(1,0)≤(2,1)，选择P3完成，所有进程均可完成。

3. 结论：当前系统处于安全状态，一个安全序列为P1→P2→P3（或P2→P1→P3）。

（3）信号量同步设计与伪代码
1. 信号量定义
- 设S1：用于同步P1与P2（P1完成后P2才能使用扫描仪），初始值=0（表示P1未完成）；
- 设S2：用于同步P2与P3（P2完成后P3才能执行），初始值=0（表示P2未完成）；
- （注：资源请求/释放逻辑需符合进程需求，P1无需B资源，P2需A和B资源，P3无需B资源）。

2. 进程核心执行伪代码
- P1的伪代码：
request(A,1);  // 请求所需的1台打印机
执行打印任务（运行10ms）;
release(A,1);  // 释放打印机
signal(S1);    // 通知P1已完成，允许P2使用扫描仪

- P2的伪代码：
wait(S1);      // 等待P1完成打印
request(A,1);  // 请求1台打印机
request(B,1);  // 请求1台扫描仪
执行扫描任务（运行8ms）;
release(A,1);  // 释放打印机
release(B,1);  // 释放扫描仪
signal(S2);    // 通知P2已完成，允许P3执行

- P3的伪代码：
wait(S2);      // 等待P2完成扫描
request(A,1);  // 请求1台打印机
执行处理任务（运行5ms）;
release(A,1);  // 释放打印机

要解决分页存储管理的相关问题，需围绕页号/页内偏移计算、页面置换算法（FIFO/LRU）的缺页次数统计及有效访问时间计算三个核心知识点展开，具体步骤如下：

问题1：逻辑地址空间的页号位数、页内偏移位数及地址转换
1.1 页号位数与页内偏移位数计算
分页存储中，页内偏移位数由页面大小决定，页号位数由逻辑地址空间大小和页内偏移位数共同决定：
页面大小 = 4KB = 4×2¹⁰B = 2¹²B，因此页内偏移位数 = log₂(2¹²) = 12位（需12位二进制表示页内地址）。
进程逻辑地址空间大小 = 64KB = 64×2¹⁰B = 2¹⁶B，因此逻辑地址总位数 = 16位。
页号位数 = 逻辑地址总位数 - 页内偏移位数 = 16 - 12 = 4位。

1.2 逻辑地址0x1A3F（十六进制）的转换
需将十六进制地址转为十进制，再通过页面大小（4096B）拆分页号和页内偏移：
1. 十六进制转十进制：  
0x1A3F = 1×16³ + 10×16² + 3×16¹ + 15×16⁰ = 4096 + 2560 + 48 + 15 = 6719（十进制）。
2. 拆分页号与页内偏移：  
页号 = 逻辑地址 // 页面大小 = 6719 // 4096 = 1（商为页号）。  
页内偏移 = 逻辑地址 % 页面大小 = 6719 % 4096 = 2623（余数为页内偏移）。

问题2：FIFO与LRU算法的缺页次数及Belady异常判断
页面访问序列（共20次）：7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1  
初始物理块为空，缺页次数含初始调入页面的次数。

2.1 FIFO（先进先出）算法
FIFO替换“最早进入内存”的页面，统计结果如下：
物理块数m为3时，缺页次数为15次，关键过程（示例）：初始调入7,0,1（3次缺页）；访问2时替换7（第4次）；后续依次替换最早页面，共15次缺页。
物理块数m为4时，缺页次数为10次，关键过程（示例）：初始调入7,0,1,2（4次缺页）；访问3时替换7（第5次）；后续替换最早页面，共10次缺页。

2.2 LRU（最近最少使用）算法
LRU替换“最长时间未被访问”的页面，统计结果如下：
物理块数m为3时，缺页次数为12次，关键过程（示例）：初始调入7,0,1（3次）；访问2时替换最久未用的7（第4次）；后续跟踪最近使用情况，共12次缺页。
物理块数m为4时，缺页次数为8次，关键过程（示例）：初始调入7,0,1,2（4次）；访问3时替换最久未用的7（第5次）；后续替换最久未用页面，共8次缺页。

2.3 Belady异常判断
Belady异常定义：物理块数增加时，缺页次数反而增加。  
本题中，FIFO算法在m=3时缺页15次，m=4时缺页10次，缺页次数随物理块数增加而减少，因此未出现Belady异常。

问题3：LRU算法（m=3）的有效访问时间
有效访问时间（EAT）公式：  
EAT = (1 - 缺页率)×内存访问时间 + 缺页率×(内存访问时间 + 缺页中断处理时间)  

已知条件：
- 内存访问时间t = 100ns  
- 缺页中断处理时间T = 20000ns  
- LRU（m=3）缺页次数 = 12次，总访问次数 = 20次  
- 缺页率p = 缺页次数 / 总访问次数 = 12/20 = 0.6  

计算过程：
1. 不缺页时的访问时间：t = 100ns  
2. 缺页时的访问时间：t + T = 100 + 20000 = 20100ns  
3. 有效访问时间：  
EAT = (1 - 0.6)×100 + 0.6×20100 = 0.4×100 + 0.6×20100 = 40 + 12060 = 12100.0ns  

最终答案
1. 页号位数为4位，页内偏移位数为12位；逻辑地址0x1A3F对应的页号为1，页内偏移为2623（十进制）。  
2. FIFO：m=3时缺页15次，m=4时缺页10次；LRU：m=3时缺页12次，m=4时缺页8次；FIFO未出现Belady异常。  
3. 有效访问时间为12100.0ns。

（1）子网掩码：255.255.255.192（或 / 26）；网络地址：192.168.1.0；可用 IP 范围：192.168.1.1~192.168.1.62
解析：① 主机需求：每个子网需≥20 台主机，主机位 n 满足 2ⁿ-2≥20→n≥5（2⁵-2=30≥20），故主机位保留 5 位以上即可；② 子网划分：需划分 4 个子网，子网位需 2 位（2²=4），原 192.168.1.0/24 的主机位为 8 位，借 2 位后子网掩码为 24+2=26 位（255.255.255.192）；③ 子网范围：4 个子网分别为 192.168.1.0/26（0~63）、192.168.1.64/26（64~127）、192.168.1.128/26（128~191）、192.168.1.192/26（192~255）；④ 主机 A 的 IP（192.168.1.30）属于第一个子网，网络地址为 192.168.1.0，可用 IP 为网络地址（0）和广播地址（63）之外的 1~62。
（2）第一次握手（A→B）：SYN=1，ACK=0，seq=1000，ack = 无；第二次握手（B→A）：SYN=1，ACK=1，seq=2000，ack=1001
解析：① TCP 三次握手规则：客户端先发送 SYN 报文（SYN=1，seq=ISN 客户端）；② 服务器回复 SYN+ACK 报文（SYN=1 表示发起服务器端连接，ACK=1 确认客户端 SYN，seq=ISN 服务器，ack = 客户端 ISN+1）；③ 本题中客户端 ISN=1000，服务器 ISN=2000，故前两次握手字段如上。
（3）最大吞吐量：320 kbps
解析：① 吞吐量计算公式（理想滑动窗口）：吞吐量 =（窗口大小 ×8）/RTT（单位：bps，8 用于将字节转为比特）；② 窗口大小 = 8KB=8×1024=8192 字节，换算为比特：8192×8=65536 比特；③ RTT=200ms=0.2 秒；④ 吞吐量 = 65536 / 0.2 = 327680 bps = 320 kbps（1kbps=1024bps，327680/1024=320）。
（4）ICMP 报文类型：目的不可达报文；类型字段值：3；代码字段值：0；原因：① ICMP 目的不可达报文（类型 3）用于告知源主机 “目的地址不可达”，其中代码 0 对应 “网络不可达”，即路由器无法找到到达目的网络的路径；② 本题中 R2 到主机 C 所在网络（202.100.1.0/24）的链路故障，R1 通过 R2 转发数据包时，R2 无法到达 C 的网络，因此 R1 向 A 发送类型 3、代码 0 的 ICMP 目的不可达报文。