2024年408真题

题目详解：

1. 初始链表结构：头结点 $h$ 指向首结点，$p$ 指向链表中某个非首非尾的结点，$q$ 未初始化。

2. 执行语句 q = p->next;：

   • $q$ 指向 $p$ 的直接后继结点。

3. 执行语句 p->next = q->next;：

   • 将 $p$ 的 $next$ 指针指向 $q$ 的直接后继结点，相当于从链表中“摘除” $q$ 结点。

4. 执行语句 q->next = h->next;：

   • 将 $q$ 的 $next$ 指针指向原链表的首结点（即 $h->next$ 所指向的结点）。

5. 执行语句 h->next = q;：

   • 将头结点 $h$ 的 $next$ 指针指向 $q$，使得 $q$ 成为新的首结点。

最终效果是将 $q$ 所指结点移动到链表的头结点之后，成为新的首结点。

正确答案：D

题目详解：
要将中缀表达式 x + y* (z – u)/v 转换为等价的后缀表达式，可以按照以下步骤进行：

1. 确定运算符的优先级：运算符的优先级从高到低为：

   • 括号 ( )
   • 乘法 * 和除法 /
   • 加法 + 和减法 -

2. 使用栈来处理运算符：

   • 初始化一个空栈和一个空列表用于输出后缀表达式。
   • 从左到右扫描中缀表达式：
     • 遇到操作数（如 x, y, z, u, v）时，直接添加到输出列表。
     • 遇到运算符时，将栈顶优先级不低于当前运算符的运算符弹出并添加到输出列表，然后将当前运算符压入栈。
     • 遇到左括号 ( 时，压入栈。
     • 遇到右括号 ) 时，弹出栈顶元素并添加到输出列表，直到遇到左括号 (，左括号弹出但不输出。

3. 具体转换过程：

   • 扫描 x：输出 x。
   • 扫描 +：压入栈 [+]。
   • 扫描 y：输出 y。
   • 扫描 *：栈顶 + 优先级低于 *，压入栈 [+, *]。
   • 扫描 (：压入栈 [+, *, (]。
   • 扫描 z：输出 z。
   • 扫描 -：栈顶 ( 不弹出，压入栈 [+, *, (, -]。
   • 扫描 u：输出 u。
   • 扫描 )：弹出 - 并输出，弹出 (，栈变为 [+, *]，输出 z u -。
   • 扫描 /：栈顶 * 优先级与 / 相同，弹出 * 并输出，压入 /，栈变为 [+, /]，输出 y z u - *。
   • 扫描 v：输出 v。
   • 表达式结束：弹出栈中剩余运算符 /, + 并输出，最终输出 x y z u - * v / +。

4. 整理后缀表达式：将输出列表连接起来，得到后缀表达式 xyzu-*v/+。

正确答案：A

题目详解：
在二叉树的中序遍历中，遍历顺序为：左子树 → 根结点 → 右子树。已知中序遍历序列为 “…, $p$, $v$, $q$, …”，且 $v$ 有两个孩子结点。我们可以分析如下：

1. 由于 $v$ 有两个孩子结点，设其左孩子为 $v_L$，右孩子为 $v_R$。中序遍历中，$v$ 的左子树会在 $v$ 之前被访问，右子树会在 $v$ 之后被访问。

2. 序列中 $p$ 出现在 $v$ 之前，说明 $p$ 是 $v$ 的左子树中的某个结点。由于中序遍历中 $p$ 是 $v$ 左子树的最后一个被访问的结点，因此 $p$ 没有右孩子（否则中序遍历会继续访问 $p$ 的右孩子，$p$ 不会是左子树的最后一个结点）。

3. 序列中 $q$ 出现在 $v$ 之后，说明 $q$ 是 $v$ 的右子树中的某个结点。由于中序遍历中 $q$ 是 $v$ 右子树的第一个被访问的结点，因此 $q$ 没有左孩子（否则中序遍历会先访问 $q$ 的左孩子，$q$ 不会是右子树的第一个结点）。

综上所述，$p$ 没有右孩子，$q$ 没有左孩子。

正确答案：A

题目详解：
根据邻接多重表还原图，由下图可知，b 的度为 2，d 的图为 4。

（图为无向图，由于编辑器原因，显示为了有向图）

题目详解：
折半查找（二分查找）是一种高效的查找算法，但要求数据结构必须满足以下条件：

1. 随机访问：能够通过下标直接访问任意位置的元素。
2. 有序性：数据必须是有序的（通常是升序或降序排列）。

我们逐一分析题目中的选项：

• I. 有序链表：虽然有序，但链表不支持随机访问（必须从头遍历），因此不适合折半查找。
• II. 无序数组：数组支持随机访问，但数据无序，无法保证折半查找的正确性。
• III. 有序静态链表：静态链表虽然有序，但其物理存储不连续，无法通过下标直接访问，因此不支持折半查找。
• IV. 无序静态链表：静态链表无序且不支持随机访问，完全不适合折半查找。

综上所述，I、II、III、IV 都不适合直接使用折半查找。

正确答案：D

题目详解：
KMP 算法中，修正后的 next 数组用于在模式匹配时决定模式串的滑动距离。模式串 $S = \text{“aabaab”}$ 的字符索引从 0 开始：

$S[0] = \text{‘a’}$
$S[1] = \text{‘a’}$
$S[2] = \text{‘b’}$
$S[3] = \text{‘a’}$
$S[4] = \text{‘a’}$
$S[5] = \text{‘b’}$

计算修正后的 next 数组（即 nextval 数组）的过程如下：

1. 计算普通 next 数组：

   • $\text{next}[0] = -1$
   • $\text{next}[1] = 0$ （$S[0]$ 与 $S[1]$ 相同）
   • $\text{next}[2] = 1$ （$S[0]$ 与 $S[1]$ 相同，$S[1]$ 与 $S[2]$ 不同）
   • $\text{next}[3] = 0$ （$S[0]$ 与 $S[3]$ 相同）
   • $\text{next}[4] = 1$ （$S[0]$ 与 $S[3]$ 相同，$S[1]$ 与 $S[4]$ 相同）
   • $\text{next}[5] = 2$ （$S[0]$ 与 $S[3]$ 相同，$S[1]$ 与 $S[4]$ 相同，$S[2]$ 与 $S[5]$ 相同）

   普通 next 数组为：$\text{next} = [-1, 0, 1, 0, 1, 2]$

2. 计算修正后的 next 数组（nextval）：

   • $\text{nextval}[0] = -1$
   • $\text{nextval}[1]$：$S[1] = S[0] = \text{‘a’}$，所以 $\text{nextval}[1] = \text{nextval}[0] = -1$
   • $\text{nextval}[2]$：$S[2] \neq S[\text{next}[2]] = S[1]$，所以 $\text{nextval}[2] = \text{next}[2] = 1$
   • $\text{nextval}[3]$：$S[3] = S[\text{next}[3]] = S[0] = \text{‘a’}$，所以 $\text{nextval}[3] = \text{nextval}[0] = -1$
   • $\text{nextval}[4]$：$S[4] = S[\text{next}[4]] = S[1] = \text{‘a’}$，所以 $\text{nextval}[4] = \text{nextval}[1] = -1$
   • $\text{nextval}[5]$：$S[5] = S[\text{next}[5]] = S[2] = \text{‘b’}$，所以 $\text{nextval}[5] = \text{nextval}[2] = 1$

   修正后的 next 数组为：$\text{nextval} = [-1, -1, 1, -1, -1, 1]$

3. 滑动距离的计算：

   • 滑动距离为 $j - \text{nextval}[j]$，其中 $j$ 是失配位置的索引。
   • 最长滑动距离对应 $j - \text{nextval}[j]$ 的最大值。
   • 对于 $j = 5$，$5 - \text{nextval}[5] = 5 - 1 = 4$
   • 对于 $j = 4$，$4 - \text{nextval}[4] = 4 - (-1) = 5$
   • 对于 $j = 3$，$3 - \text{nextval}[3] = 3 - (-1) = 4$
   • 对于 $j = 2$，$2 - \text{nextval}[2] = 2 - 1 = 1$
   • 对于 $j = 1$，$1 - \text{nextval}[1] = 1 - (-1) = 2$
   • 对于 $j = 0$，$0 - \text{nextval}[0] = 0 - (-1) = 1$

   最长滑动距离为 $5$（对应 $j = 4$）。

正确答案：A

题目详解：
根据二叉搜索树的性质，$K_2$ 的左子树的节点关键字均小于 $K_2$，可以得出 $K_3 < K_2$，$T$ 中所有节点小于 $K_2$，同理也可以得出 $K_3$ 的右子树节点均大于 $K_3$，即 $T$ 中所有节点 $> K_3$，$X$ 是 $T$ 中节点，由此可以得出 $K_3 < X < K_2$。

题目详解：
快速排序的第一趟排序会将数组 $M$ 划分为三个部分：枢轴元素、 $P$ 块和 $Q$ 块。枢轴元素的位置已经确定，且 $P$ 块中的所有元素均小于等于枢轴元素， $Q$ 块中的所有元素均大于等于枢轴元素。因此， $P$ 块和 $Q$ 块之间是有序的，即 $P$ 块中的任意元素都小于等于 $Q$ 块中的任意元素。

选项分析：

• A. 正确。 $P$ 和 $Q$ 块间有序，因为 $P$ 的所有元素 ≤ 枢轴 ≤ $Q$ 的所有元素。
• B. 错误。第一趟排序后， $P$ 和 $Q$ 块内部不一定有序，因为快速排序是递归地对子块进行排序的。
• C. 错误。 $P$ 和 $Q$ 的元素个数是否相等取决于枢轴的选择，题目中并未说明枢轴是中位数，因此不一定大致相等。
• D. 错误。 $P$ 和 $Q$ 中可能存在相等的元素，只要这些元素满足 $P$ 的元素 ≤ 枢轴 ≤ $Q$ 的元素即可。

正确答案：A

题目详解：
首先，我们需要明确大根堆的性质：在大根堆中，每个节点的值都大于或等于其子节点的值。初始的大根堆序列为 $28, 22, 20, 19, 8, 12, 15, 5$ ，其对应的堆结构如下：

28
 /\
 2220
/ \ / \
198 12 15
 /
5

第一次删除操作：删除堆顶元素 $28$ 。删除堆顶元素后，通常将堆的最后一个元素 $5$ 移动到堆顶，然后进行堆调整（Heapify）：

1. 将 $5$ 移动到堆顶：

   复制代码

   5
   /\
   22 20
    / \/ \
    19812 15

2. 调整堆：由于 $5$ 比其子节点 $22$ 和 $20$ 小，需要与较大的子节点交换。 $22$ 是较大的子节点，因此交换 $5$ 和 $22$ ：

22
 /\
 5 20
/ \ / \
198 12 15

3. 继续调整： $5$ 比其子节点 $19$ 和 $8$ 小，需要与较大的子节点交换。 $19$ 是较大的子节点，因此交换 $5$ 和 $19$ ：

22
 /\
 19 20
/ \/ \
5 812 15

调整后的堆序列为 $22, 19, 20, 5, 8, 12, 15$ 。

第二次删除操作：删除堆顶元素 $22$ 。删除堆顶元素后，将堆的最后一个元素 $15$ 移动到堆顶，然后进行堆调整：

1. 将 $15$ 移动到堆顶：

15
 / \
 19 20
/ \/
58 12

2. 调整堆： $15$ 比其子节点 $19$ 和 $20$ 小，需要与较大的子节点交换。 $20$ 是较大的子节点，因此交换 $15$ 和 $20$ ：

20
 / \
 19 15
/ \/
58 12

调整后的堆序列为 $20, 19, 15, 5, 8, 12$ 。

最终得到的新堆序列为 $20, 19, 15, 5, 8, 12$ ，对应选项 B。

正确答案：B

题目详解：
首先，我们需要明确二路归并排序的过程。归并排序的基本操作是将两个有序序列合并为一个有序序列，每次比较两个序列的第一个元素，将较小的元素放入结果序列中，并移动相应序列的指针。每次比较都会消耗一次比较次数。

初始有序序列为：$(3, 5)$、$(7, 9)$ 和 $(6)$。

按从左至右的次序进行归并排序，步骤如下：

1. 首先归并 $(3, 5)$ 和 $(7, 9)$：

   • 比较 $3$ 和 $7$，$3$ 较小，放入结果序列。比较次数 $+1$。结果序列：$(3)$。
   • 比较 $5$ 和 $7$，$5$ 较小，放入结果序列。比较次数 $+1$。结果序列：$(3, 5)$。
   • 此时 $(3, 5)$ 已全部放入结果序列，剩下的 $(7, 9)$ 直接追加。结果序列：$(3, 5, 7, 9)$。
   • 总比较次数：$2$ 次。

2. 接下来归并 $(3, 5, 7, 9)$ 和 $(6)$：

   • 比较 $3$ 和 $6$，$3$ 较小，放入结果序列。比较次数 $+1$。结果序列：$(3)$。
   • 比较 $5$ 和 $6$，$5$ 较小，放入结果序列。比较次数 $+1$。结果序列：$(3, 5)$。
   • 比较 $7$ 和 $6$，$6$ 较小，放入结果序列。比较次数 $+1$。结果序列：$(3, 5, 6)$。
   • 此时 $(6)$ 已全部放入结果序列，剩下的 $(7, 9)$ 直接追加。结果序列：$(3, 5, 6, 7, 9)$。
   • 总比较次数：$3$ 次。

3. 总比较次数为两次归并的比较次数之和：$2 + 3 = 5$ 次。

正确答案：C

题目详解：
在外排序的多路归并过程中，败者树（Loser Tree）是一种高效的数据结构，用于从多个归并段中选择最小关键字。败者树的基本工作原理如下：

1. 败者树的结点类型：败者树的内部结点记录的是“失败者”（即比较中较大的关键字或其归并段号），而“冠军”（即当前最小的关键字）会被传递到根结点或特定的冠军结点。

2. 冠军的含义：在败者树中，“冠军”指的是当前所有归并段中最小的关键字。因此，记录“冠军”的结点保存的是最小关键字所在的归并段号，而不是关键字本身。这是因为败者树的内部结点仅存储失败者的信息，而冠军信息需要动态传递。

3. 升序归并段的特点：题目中提到归并段是初始为升序的，因此每次从各个归并段取出的第一个关键字就是该段的最小关键字。败者树的作用是快速找到这些最小关键字中的全局最小者。

4. 选项分析：

   • A. 最大关键字：错误，败者树的目标是找最小关键字。
   • B. 最小关键字：错误，冠军结点不直接保存最小关键字，而是保存其归并段号。
   • C. 最大关键字所在的归并段号：错误，败者树不关注最大关键字。
   • D. 最小关键字所在的归并段号：正确，冠军结点保存的是最小关键字所在的归并段号。

正确答案：D

题目详解：
在C语言中，数据类型转换涉及以下关键点：

1. 初始赋值：

   • int i = 32777;：变量 $i$ 被赋值为 $32777$，这是一个合法的 $\text{int}$ 值（通常 $\text{int}$ 为4字节，范围 $-2^{31}$ 到 $2^{31}-1$）。

2. 从 $\text{int}$ 到 $\text{short}$ 的隐式转换：

   • short si = i;：$\text{short}$ 通常是2字节有符号整数，范围 $-32768$ 到 $32767$。
   • $32777$ 超出 $\text{short}$ 的范围，会发生截断。具体过程：
     • $32777$ 的二进制表示为 $1000000000001001$（16位）。
     • 最高位为 $1$，因此 $\text{short}$ 解释为负数，其值为 $-32768 + (32777 - 32768) = -32768 + 9 = -32759$。

3. 从 $\text{short}$ 到 $\text{int}$ 的隐式转换：

   • int j = si;：$\text{short}$ 的 $-32759$ 直接转换为 $\text{int}$，值保持不变，因此 $j = -32759$。

最终 $j$ 的值为 $-32759$。

正确答案：B

题目详解：
在计算机系统中，CPU 直接执行的是最低层次的指令，具体分析如下：

1. 伪指令（I）：这是汇编语言中由程序员定义的指令序列，用于简化编程。CPU 不能直接执行伪指令，需要先由汇编器将其转换为机器指令。

2. 微指令（II）：这是微程序控制单元中的底层指令，用于控制硬件操作。CPU 的微程序控制器可以直接执行微指令。

3. 机器指令（III）：这是二进制形式的指令，CPU 可以直接解码和执行机器指令。

4. 汇编指令（IV）：这是汇编语言中的指令，需要先由汇编器转换为机器指令后才能被 CPU 执行。

因此，CPU 能直接执行的是 微指令（II） 和 机器指令（III）。

正确答案：B

题目详解：
首先，我们需要分析整型参数 α 和 β 的取值范围，并确定适合的数据表示方法。

1. 参数 α 的取值范围为－220～220：

   • 这个范围可以用有符号的 32 位整数（int32）表示，因为 32 位整数的取值范围是 $-2^{31}$ 到 $2^{31}-1$，即 $-2147483648$ 到 $2147483647$，完全覆盖 α 的范围。
   • 单精度浮点数（float32）虽然可以表示这个范围内的数，但整型运算速度更快且精度更高，因此 α 更适合用 32 位整数表示。

2. 参数 β 的取值范围为－240～240：

   • 这个范围超过了 32 位整数的表示范围（因为 $2^{31}-1 = 2147483647$，而 $240^{240}$ 是一个非常大的数），因此 32 位整数无法表示 β。
   • 单精度浮点数（float32）的指数部分可以表示较大的数，但其有效位数有限（约 7 位十进制精度），对于 $240^{240}$ 这种大数，精度可能不足。
   • 双精度浮点数（float64）的指数范围和有效位数（约 15 位十进制精度）更适合表示 β，因此 β 最适合用双精度浮点数表示。

综上所述，α 最适宜采用 32 位整数，β 最适宜采用双精度浮点数。

正确答案：C

题目详解：
关于整数乘法运算的叙述，我们逐一分析各选项：

A. 阵列乘法器采用并行结构，通过多个加法器同时计算部分积并累加，因此可以在 一个时钟周期 内完成乘法运算。该叙述正确。

B. 使用 ALU 和移位器 实现乘法时，通常采用串行方式（如 Booth 算法），需要通过多次移位和加法迭代完成，因此无法在一个时钟周期内完成。该叙述正确。

C. 当乘数为常数时，编译器可将其分解为 $2^n$ 的线性组合（例如 $13 = 2^3 + 2^2 + 2^0$），从而用移位（<<）和加减指令替代乘法指令。该叙述正确。

D. 两个变量的乘法虽无法直接优化为固定指令序列，但可通过 循环结构 实现（如累加移位）。例如，用加法器和计数器实现迭代乘法。因此“无法转换”的说法错误。

正确答案：D

题目详解：
在页式虚拟存储管理系统中，存储器层次结构的设计涉及不同层次之间的数据交换和管理策略。以下是各选项的详细分析：

A. 正确。$Cache–主存$ 层次的交换单位是主存块（$Cache \ line$ 或 $Cache \ block$），而 $主存–外存$ 层次的交换单位是页（$Page$）。这是存储器层次结构的典型设计。

B. 正确。$Cache–主存$ 层次的替换算法（如 $LRU$、$FIFO$ 等）通常由硬件实现，以提高速度；而 $主存–外存$ 层次的替换算法（如页面置换算法）通常由操作系统（软件）实现，因为外存访问速度较慢，软件实现更灵活。

C. 正确。$Cache–主存$ 层次可以采用回写法（$Write-back$）或直写法（$Write-through$），而 $主存–外存$ 层次通常采用回写法（$Write-back$），因为外存访问速度慢，回写可以减少外存访问次数。

D. 错误。$Cache–主存$ 层次可以采用直接映射（$Direct \ Mapping$）、全相联映射（$Fully \ Associative$）或组相联映射（$Set \ Associative$），但 $主存–外存$ 层次通常采用全相联映射（$Fully \ Associative$），因为页表需要支持任意页映射到任意主存页框，而不是直接映射。直接映射会导致严重的冲突问题，不适合虚拟存储系统。

正确答案：D

题目详解：
虚拟地址为 32 位，页大小为 1KB ($2^{10}$ 字节)，因此页内偏移地址占 10 位。虚拟页号 (VPN) 的位数为 $32 - 10 = 22$ 位。

TLB 共有 32 个表项，采用 4 路组相联映射方式，因此 TLB 的组数为 $\frac{32}{4} = 8$ 组。组索引需要的位数为 $\log_2 8 = 3$ 位。

TLB 表项中的标记字段 (Tag) 位数为虚拟页号位数减去组索引位数，即 $22 - 3 = 19$ 位。

因此，TLB 表项中标记字段的位数至少是 19 位。

正确答案：C

题目详解：
在 MMU（内存管理单元）进行地址转换的过程中，会涉及以下事件的检测：

1. 访问越权（A）：MMU 会检查当前进程是否有权限访问目标地址（例如用户态进程试图访问内核空间地址），若越权则触发异常。

2. 页面缺失（C）：MMU 通过页表查询物理地址时，若目标页表项标记为“不存在”或未加载到内存，则触发缺页异常（Page Fault）。

3. TLB 缺失（D）：MMU 首先查询 TLB（快表）加速地址转换，若 TLB 未命中（缺失），则需继续查询页表。

而 Cache 缺失（B） 是 CPU 访问缓存时的事件，与 MMU 的地址转换过程无关。Cache 缺失由硬件缓存机制处理，不涉及地址权限或映射关系的检查。

因此，Cache 缺失 不是 MMU 地址转换过程中检测的事件。

正确答案：B

题目详解：
在5段流水线RISC数据通路中，数据冒险是指由于指令之间的数据依赖性导致流水线无法正确执行的情况。以下是各选项的详细分析：

1. 选项A：相邻两条指令中的操作数相关可能引起数据冒险。这是正确的，例如当前指令需要用到上一条指令的计算结果（如 $R1 = R2 + R3$ 后接 $R4 = R1 + R5$），就会发生数据冒险。

2. 选项B：在数据相关的指令间插入“气泡”（即流水线停顿）能避免数据冒险。这是正确的，插入气泡可以让前一条指令完成写回阶段后再执行下一条指令，从而避免数据冲突。

3. 选项C：所有数据冒险都可以通过加入转发（旁路）电路解决。这是错误的。转发电路可以解决大部分数据冒险，例如在 $EX$ 阶段的结果可以直接转发给下一条指令的 $EX$ 阶段。但对于某些情况（如加载-使用型冒险，即 $lw$ 指令后立即使用其结果的指令），转发无法完全避免冒险，仍需插入气泡。

4. 选项D：所有数据冒险都能通过调整指令顺序和插入 $nop$ 指令解决。这是正确的，通过调整指令顺序或插入 $nop$ 可以消除所有数据冒险，尽管可能会降低性能。

正确答案：C

题目详解：
总线带宽（最大数据传输率）的计算公式为：
$\text{总线带宽} = \text{有效数据传输速率} \times \text{总线宽度}$

其中，有效数据传输速率需要考虑时钟频率和每个时钟周期传送数据的次数。题目中给出：

• 时钟频率 $f = 420 \text{MHz} = 420 \times 10^6 \text{Hz}$
• 每个时钟周期传送 $n = 2$ 次数据
• 总线宽度 $w = 64 \text{位} = 8 \text{字节}$

首先计算有效数据传输速率：
$\text{有效数据传输速率} = f \times n = 420 \times 10^6 \times 2 = 840 \times 10^6 \text{次数据传输/秒}$

然后计算总线带宽：
$\text{总线带宽} = 840 \times 10^6 \times 8 \text{字节} = 6720 \times 10^6 \text{字节/秒} = 6.72 \text{GB/s}$

题目中还提到突发传送方式，但最大数据传输率由时钟频率、总线宽度和每个时钟周期传送数据的次数决定，突发传送方式不影响最大带宽的计算。

正确答案：B

题目详解：
中断 I/O 方式是计算机系统中一种重要的 I/O 控制方式，其核心是通过中断机制实现 CPU 和 I/O 设备之间的并行工作。下面逐项分析：

A. 中断屏蔽字用于确定中断响应的优先级
错误。中断屏蔽字的作用是 屏蔽 某些中断源的中断请求，而不是确定优先级。中断优先级通常由 硬件排队电路 或 软件查询顺序 决定。中断屏蔽字可以动态改变当前 CPU 对中断的响应情况。

B. 保存断点和程序状态字在中断响应阶段完成
正确。中断响应阶段由硬件自动完成：

• 保存断点（PC值）到 栈 或 固定内存单元
• 保存程序状态字（PSW）
• 关中断（进入不可响应中断状态）

C. 保存通用寄存器和设置新中断屏蔽字由软件实现
正确。这些操作属于 中断处理程序 的工作，由软件完成：

• 保存通用寄存器（通过 PUSH 指令）
• 设置新的中断屏蔽字（根据处理需求调整）

D. 单重中断方式下中断处理时 CPU 处于关中断状态
正确。单重中断的特点是：

• 执行中断服务程序期间 不响应新中断
• 只有中断处理完成后（通过 STI 指令）才会重新开中断

正确答案：A

题目详解：
在 DMA (Direct Memory Access) 控制 I/O 方式下，数据传输的过程绕过了 CPU，直接由 DMA 控制器管理。DMA 控制器负责在 I/O 设备和主存之间建立直接的数据传输通路。具体来说：

1. DMA 控制器独立于 CPU 工作，它通过总线与主存和 I/O 设备接口相连。
2. 当 I/O 设备需要传输数据时，DMA 控制器会接管总线控制权，直接在 设备接口 和 主存 之间传输数据，无需 CPU 干预。
3. 因此，DMA 控制器控制的数据传输通路位于 设备接口 和 主存 之间。

选项 A (CPU 和主存之间) 和选项 B (CPU 和 DMA 控制器之间) 错误，因为 DMA 方式下数据传输不经过 CPU。选项 D (设备接口和 DMA 控制器之间) 也不正确，因为 DMA 控制器是中介，数据最终传输的目标是主存。

正确答案是 C。

题目详解：
中断、异常和系统调用是计算机系统中的三种重要机制，它们的处理方式和特点有所不同：

1. 中断（Interrupt）：

   • 中断是由外部设备（如键盘、鼠标、磁盘等）触发的异步事件。
   • 中断发生时，CPU 可能处于用户态或内核态。
   • 中断处理程序开始执行时，CPU 会切换到内核态（选项 C 正确）。
   • 添加新设备时需要注册相应的中断服务例程（选项 D 正确）。

2. 异常（Exception）：

   • 异常是由 CPU 执行指令时同步触发的，如除零错误、缺页异常等。
   • 异常发生时，CPU 可能处于用户态或内核态。
   • 异常处理程序开始执行时，CPU 会切换到内核态。

3. 系统调用（System Call）：

   • 系统调用是用户程序主动请求内核服务的接口。
   • 每个系统调用都有对应的内核服务例程（选项 B 正确）。
   • 系统调用通过软中断或专用指令触发，执行时会切换到内核态。

选项 A 错误的原因是：中断或异常发生时，CPU 不一定处于内核态。例如，用户程序执行时触发的异常（如除零错误）或设备中断，CPU 可能处于用户态。

正确答案：A

题目详解：
在操作系统终止一个进程时，通常会执行以下操作：

1. 回收进程占用的设备：操作系统会释放该进程占用的所有I/O设备，以便其他进程可以使用。这是必须执行的步骤，对应选项 $B$。

2. 撤销进程控制块（PCB）：进程控制块是操作系统管理进程的核心数据结构，终止进程时必须撤销其PCB，对应选项 $C$。

3. 回收为进程分配的内存：操作系统会回收该进程占用的所有内存资源，防止内存泄漏，对应选项 $D$。

然而，终止子进程并不一定是操作系统在终止当前进程时必须执行的操作。子进程可能由其他进程接管（例如由 $init$ 进程接管），或者子进程可能已经终止。因此，选项 $A$ 是操作系统在终止进程时不一定执行的操作。

正确答案：A

题目详解：
在支持页式存储管理的系统中，进程切换时操作系统需要执行以下关键操作：

1. 更新程序计数器（PC）的值：程序计数器保存了当前进程执行的下一条指令地址。进程切换时必须保存当前进程的PC值，并加载新进程的PC值，以确保新进程从正确的指令开始执行。

2. 更新栈基址寄存器值：每个进程都有独立的栈空间，用于保存函数调用、局部变量等信息。进程切换时需要更新栈基址寄存器（如 $esp$ 或 $rsp$ ），以确保新进程使用自己的栈空间。

3. 更新页表基地址寄存器值：页式存储管理中，每个进程有自己的页表，页表基地址寄存器（如 $CR3$ ）保存了当前进程页表的物理地址。进程切换时必须更新该寄存器，以确保MMU能够正确转换新进程的虚拟地址。

因此，进程切换时操作系统需要执行 I、II、III 全部操作。

正确答案：D

题目详解：
文件系统管理空闲块的方法主要有以下几种：

1. 位图法（A选项）：
   使用一个位图（bitmap）来表示磁盘块的使用情况，每个块对应一个二进制位（$0$ 表示空闲，$1$ 表示已占用）。位图的大小仅与磁盘总块数 $N$ 有关，计算公式为 $\lceil \frac{N}{8} \rceil$ 字节，与当前空闲块数量无关。

2. 空闲表法（B选项）：
   维护一个空闲块表，记录所有连续空闲块的起始块号和长度。空闲表的大小与当前空闲块的数量和分布情况直接相关。

3. 成组链接法（C选项）：
   将空闲块分组，通过链表链接。每组的大小固定，但需要额外的指针存储链接信息，其占用空间与空闲块数量相关。

4. 空闲链表法（D选项）：
   将所有空闲块通过指针链接成链表，每个空闲块需存储指针信息，因此占用空间与空闲块数量成正比。

综上，只有 位图法 的占用空间与磁盘总块数相关，而与当前空闲块数量无关。

正确答案：A

题目详解：
在内存管理中，不同的分区分配算法有不同的特点和策略。题目中描述的算法需要满足“每次回收分区时仅合并大小相等的空闲分区”这一条件。我们逐一分析各选项：

1. 伙伴算法（A选项）：

   • 伙伴算法将内存划分为大小相等的块，每个块的大小为 $2^n$。
   • 当释放一个块时，算法会检查其“伙伴”块（即大小相同且地址相邻的块）是否空闲。如果伙伴块空闲，则合并这两个块，形成一个更大的块。
   • 合并操作仅限于大小相等的空闲分区，因此完全符合题目描述。

2. 最佳适应算法（B选项）：

   • 最佳适应算法在分配内存时，从所有空闲分区中选择一个大小最接近请求大小的分区。
   • 回收分区时，没有限制必须合并大小相等的空闲分区，因此不符合题目描述。

3. 最坏适应算法（C选项）：

   • 最坏适应算法在分配内存时，从所有空闲分区中选择一个最大的分区。
   • 回收分区时，同样没有限制必须合并大小相等的空闲分区，因此不符合题目描述。

4. 首次适应算法（D选项）：

   • 首次适应算法在分配内存时，从内存的低地址开始查找第一个满足条件的空闲分区。
   • 回收分区时，也没有限制必须合并大小相等的空闲分区，因此不符合题目描述。

综上所述，只有伙伴算法满足题目中“每次回收分区时仅合并大小相等的空闲分区”的条件。

正确答案：A

题目详解：
在进程 $P$ 中，线程 $T$、$Ta$ 和 $Tb$ 共享以下资源：

1. 进程 $P$ 的地址空间（I）：所有线程共享同一个进程的地址空间，包括代码段、数据段和堆等。因此，$Ta$ 和 $Tb$ 可以共享进程 $P$ 的地址空间。

2. 线程 $T$ 的栈（II）：每个线程拥有自己独立的栈空间，用于存储局部变量和函数调用信息。因此，$Ta$ 和 $Tb$ 不能共享线程 $T$ 的栈。

3. 文件描述符 $fd$（III）：文件描述符是进程级别的资源，由进程内的所有线程共享。因此，$Ta$ 和 $Tb$ 可以共享文件描述符 $fd$。

综上所述，$Ta$ 与 $Tb$ 可共享的资源是 I 和 III。

正确答案：B

题目详解：
在操作系统中，文件按名查找功能通常由 $open()$ 系统调用实现。以下是各选项的功能分析：

1. $open()$：该系统调用的主要功能是根据文件名查找文件，并返回一个文件描述符。它首先需要在文件系统中按名称定位文件，因此包含文件按名查找功能。

2. $read()$：该系统调用的功能是从已打开的文件中读取数据，它需要文件描述符作为参数，而不涉及按名称查找文件。

3. $write()$：该系统调用的功能是向已打开的文件中写入数据，同样需要文件描述符作为参数，不涉及按名称查找文件。

4. $close()$：该系统调用的功能是关闭已打开的文件，释放文件描述符，不涉及按名称查找文件。

因此，只有 $open()$ 系统调用包含文件按名查找功能。

正确答案：A

题目详解：
在时间片轮转调度算法中，每个进程每次最多执行一个时间片（这里是 $5ms$）的长度。系统共有 $10$ 个进程，初始时均处于就绪队列。进程 $P$ 位于队尾，所需 CPU 时间为 $25ms$。

计算进程 $P$ 的周转时间时，需要考虑以下几点：

1. 每次轮转时，进程 $P$ 需要等待其他 $9$ 个进程先执行完各自的时间片，然后才能执行自己的时间片。
2. 进程 $P$ 需要 $\frac{25ms}{5ms} = 5$ 个时间片才能完成。
3. 在每次执行自己的时间片之前，进程 $P$ 需要等待其他 $9$ 个进程执行完一个时间片，因此每次等待时间为 $9 \times 5ms = 45ms$。
4. 进程 $P$ 需要经历 $5$ 次这样的等待，总等待时间为 $5 \times 45ms = 225ms$。
5. 进程 $P$ 自身执行时间为 $25ms$，因此周转时间为 $225ms + 25ms = 250ms$。

正确答案：C

题目详解：
在计算机系统中，键盘中断服务例程（ISR）的执行过程涉及多个硬件和软件组件的协作。以下是详细步骤：

1. 当用户按下键盘上的某个键时，键盘控制器会检测到该动作，并将对应的扫描码存储在 键盘控制器的数据寄存器（选项 D）中。

2. 键盘控制器随后向 CPU 发送一个中断请求（IRQ），通知 CPU 有新的输入数据需要处理。

3. CPU 响应中断后，会暂停当前任务，并跳转到预定义的 键盘中断服务例程（ISR）执行。

4. 在 ISR 执行期间，系统会从键盘控制器的数据寄存器中读取扫描码，并将其转换为对应的字符编码（如 ASCII 码）。

5. 转换后的字符数据不会直接存入 用户缓冲区（选项 A），因为用户空间无法直接访问中断上下文。同时，数据也不会长期存储在 CPU 中的通用寄存器（选项 B）中，因为寄存器仅用于临时存储。

6. 为了保证数据的安全性和系统的稳定性，转换后的字符数据会被存入 内核缓冲区（选项 C）。内核缓冲区是操作系统内核管理的一块内存区域，专门用于临时存储输入设备的数据。

7. 最后，当用户程序通过系统调用（如 read）请求输入时，数据会从内核缓冲区复制到用户缓冲区，供应用程序使用。

因此，键盘中断服务例程执行结束时，输入数据的最终存放位置是 内核缓冲区。

正确答案：C

题目详解：
循环扫描算法（CSCAN）的特点是在磁头移动到磁盘一端时会立即返回到另一端继续扫描。题目中磁头完成对 $200$ 号磁道的请求后，向磁道号减小的方向移动，说明磁头会从 $200$ 开始向 $0$ 方向移动，到达 $0$ 后再跳转到最大磁道号 $399$ 继续向 $0$ 方向移动。

初始磁头位置：$200$
磁头移动方向：磁道号减小

待处理请求磁道号按初始顺序为：$300$, $120$, $110$, $0$, $160$, $210$, $399$

按照 CSCAN 算法，磁头移动路径如下：

1. 从 $200$ 向 $0$ 方向移动，依次访问 $160$, $120$, $110$, $0$。
2. 到达 $0$ 后立即跳转到 $399$ 并继续向 $0$ 方向移动，依次访问 $399$, $300$, $210$。

具体移动距离计算：

• $200 \rightarrow 160$：$|200 - 160| = 40$
• $160 \rightarrow 120$：$|160 - 120| = 40$
• $120 \rightarrow 110$：$|120 - 110| = 10$
• $110 \rightarrow 0$：$|110 - 0| = 110$
• $0 \rightarrow 399$：$|0 - 399| = 399$（跳转）
• $399 \rightarrow 300$：$|399 - 300| = 99$
• $300 \rightarrow 210$：$|300 - 210| = 90$

总移动距离：$40 + 40 + 10 + 110 + 399 + 99 + 90 = 788$

正确答案：C

题目详解：
H1 和 H2 两端的最大传输速率为 10Mbps，虽然中间的路由器最大传输速率为 1000Mbps, 但是根据网路最大流算法，HI 和 H2 的最大吞吐量等价于最大流，最大流为 1OMbps。

正确答案：B

题目详解：
在二进制数字调制方法中，不同的调制技术需要不同数量的载波参数：

1. ASK (Amplitude Shift Keying)：使用 1 个载波频率，通过改变载波的振幅来表示二进制数据。例如，高振幅表示 $1$，低振幅表示 $0$。

2. PSK (Phase Shift Keying)：使用 1 个载波频率，通过改变载波的相位来表示二进制数据。例如，$0^\circ$ 相位表示 $1$，$180^\circ$ 相位表示 $0$。

3. FSK (Frequency Shift Keying)：使用 2 个不同频率的载波，通过切换载波频率来表示二进制数据。例如，频率 $f_1$ 表示 $1$，频率 $f_2$ 表示 $0$。

4. DPSK (Differential Phase Shift Keying)：是 PSK 的一种变体，仍然使用 1 个载波频率，通过相邻符号的相位变化来表示二进制数据。

因此，FSK 是唯一需要 2 个不同频率载波的调制方法。

正确答案：C

题目详解：
由图可知，VLAN1 中包含 H1、H2、H3 和 H4；VLAN2 中包含 H5；VLAN3 中包含 H6 和 H7。

A 和 H2 有关，H2 和 H4 都位于 VLAN1 中，因此该项会出现在 H4 的 ARP 表中。

B 和 H1 有关，H1 和 H4 都位于 VLAN1 中，因此该项会出现在 H4 的 ARP 表中。

C 和 H3 有关，H3 和 H4 都位于 VLAN1 中，因此该项会出现在 H4 的 ARP 表中。

D 和 H6 有关，H6 位于 VLAN3 中，而 H4 都位于 VLAN1 中，两者不在同一个 VLAN 中，因此该项不会出现在 H4 的 ARP 表中。

正确答案：D

题目详解：
在CSMA/CA协议中，网络分配向量（NAV）用于表示信道被占用的时间。隐藏站B在收到AP发送的CTS帧时，会根据CTS帧中的持续时间字段设置NAV值。NAV的计算包括以下步骤：

1. 数据传输时间：主机A发送数据帧的时间。

   • 数据帧长度：$1998 \text{B} = 1998 \times 8 \text{bits} = 15984 \text{bits}$
   • 无线链路带宽：$54 \text{Mb/s} = 54 \times 10^6 \text{bits/s}$
   • 数据传输时间：$T_{\text{data}} = \frac{15984}{54 \times 10^6} = 296 \mu \text{s}$

2. ACK帧传输时间：AP发送ACK帧的时间。

   • ACK帧传输时延：$T_{\text{ACK}} = 2 \mu \text{s}$

3. SIFS时间：短帧间间隔。

   • $\text{SIFS} \geq 28 \mu \text{s}$

4. NAV值计算：NAV包括数据传输时间、ACK帧传输时间和两次SIFS时间（一次在数据帧之后，一次在ACK帧之后）。

   • $\text{NAV} = T_{\text{data}} + T_{\text{ACK}} + 2 \times \text{SIFS}$
   • 代入数值：$\text{NAV} = 296 + 2 + 2 \times 28 = 354 \mu \text{s}$

因此，隐藏站B设置的NAV值为 $354 \mu \text{s}$。

正确答案：B

题目详解：
在 $t_1$ 时刻主机甲接收到了主机乙发送的 ACKO，暂时没有出错的帧，所以继续发送下一个数据帧 F4。在 $t_2$ 时刻主机甲收到了 F1 超时的错误，根据选择性重传，发送方只需要重传出错的帧，而不是所有的帧，所以只需要重新发送 F1。

题目详解：

1. 建立TCP连接（三次握手）：

   • 第一次握手：H 发送 SYN 报文，耗时 $\frac{RTT}{2} = 5ms$。
   • 第二次握手：服务器回复 SYN+ACK 报文，耗时 $\frac{RTT}{2} = 5ms$。
   • 第三次握手：H 发送 ACK 报文，此时连接建立完成。
   • 总耗时：$RTT = 10ms$。

2. 数据传输：

   • 报文长度 $3000B$，MSS $1000B$，需要分 $3$ 个段传输。
   • 每个段的传输时间忽略（题目说明忽略传输时延），但需要等待 ACK。
   • 发送第一个段后等待 ACK，耗时 $RTT = 10ms$。
   • 发送第二个段后等待 ACK，耗时 $RTT = 10ms$。
   • 发送第三个段后等待 ACK，耗时 $RTT = 10ms$。
   • 总耗时：$3 \times RTT = 30ms$。

3. 断开TCP连接（四次挥手）：

   • 第一次挥手：H 发送 FIN 报文，耗时 $\frac{RTT}{2} = 5ms$。
   • 第二次挥手：服务器回复 ACK 报文，耗时 $\frac{RTT}{2} = 5ms$。
   • 第三次挥手：服务器发送 FIN 报文，耗时 $\frac{RTT}{2} = 5ms$。
   • 第四次挥手：H 发送 ACK 报文，此时 H 进入 TIME-WAIT 状态。
   • 总耗时：$2 \times RTT = 20ms$（因为第二次和第三次挥手可以合并为一次传输）。

4. TIME-WAIT 状态：

   • H 需要等待 $2 \times MSL = 60s$ 以确保服务器收到最后的 ACK。
   • 耗时：$60s$。

5. 总时间计算：

   • 建立连接：$10ms$。
   • 数据传输：$30ms$。
   • 断开连接：$20ms$。
   • TIME-WAIT：$60s$。
   • 总时间：$10ms + 30ms + 20ms + 60s = 60.06s$。
   • 但题目问的是“至少”时间，实际 TIME-WAIT 的 $60s$ 已经覆盖了前面的耗时，因此总时间为 $60s + 40ms = 60.04s$（因为前面的 $60ms$ 可以部分重叠）。

正确答案：D

题目详解：
以下是修正后的格式，确保公式正确显示：

UDP 校验和的计算步骤如下：

1. 将中间结果 $1011\ 1001\ 1011\ 0110$ 和最后一个 16 位数 $0110\ 0101\ 1100\ 0101$ 相加：

   $$\begin{aligned} &\ \ \ \ 1011\ 1001\ 1011\ 0110 \\ +\ &\ \ 0110\ 0101\ 1100\ 0101 \\ \hline &\ \ 1\ 0001\ 1111\ 0111\ 1011 \end{aligned}$$

   由于相加结果产生了最高位的进位（即第 17 位为 1），需要将进位回卷（wraparound）加到最低位：

   $$\begin{aligned} &\ \ \ \ 0001\ 1111\ 0111\ 1011 \\ +\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 1 \\ \hline &\ \ \ \ 0001\ 1111\ 0111\ 1100 \end{aligned}$$

2. 对上述结果取反码（即将所有位取反），得到最终的校验和：

   $$\begin{aligned} &\ \ \ \ 0001\ 1111\ 0111\ 1100 \\ \text{取反后：} \\ &\ \ \ \ 1110\ 0000\ 1000\ 0011 \end{aligned}$$

因此，最终计算得到的校验和是 $1110\ 0000\ 1000\ 0011$。

正确答案：C

题目详解：
在非持久的HTTP/1.0 协议中，每个TCP 连接只能用于传输一个对象（如HTML 文件或图像文件）。由于浏览器不支持并行TCP 连接，因此所有请求必须按顺序进行。具体步骤如下：

1. 建立TCP 连接请求Web 页（HTML 文件）：

   • 需要 $1$ 个RTT 用于TCP 连接的建立（三次握手）。
   • 需要 $1$ 个RTT 用于HTTP 请求和HTML 文件的传输。
   • 总共需要 $2$ 个RTT 完成HTML 文件的传输。

2. 解析HTML 文件后，发现引用了 $7$ 个小图像文件，需要为每个图像文件重复以下过程：

   • 建立TCP 连接：$1$ 个RTT。
   • HTTP 请求和图像文件传输：$1$ 个RTT。
   • 每个图像文件总共需要 $2$ 个RTT。

3. 对于 $7$ 个图像文件，总共需要 $7 \times 2 = 14$ 个RTT。

4. 将HTML 文件和图像文件的RTT 相加：

   • HTML 文件：$2$ 个RTT。
   • 图像文件：$14$ 个RTT。
   • 总计：$2 + 14 = 16$ 个RTT。

因此，最少需要 $16$ 个RTT 才能完成所有内容的传输。

正确答案：D

题目详解：
1）算法基本设计思想

输出拓扑序列的过程如下：依次从图中选取入度为 0 的点进行输出。

确保拓扑序列唯一需要保证如下条件：在输出拓扑序列时，每一次有且仅有入度为 0 的顶点。

所以这题最直观的思路就是进行 $numEdges$ 轮遍历，如果每轮遍历只有一个顶点的入度为 0，则图中存在唯一的拓扑序列； 否则不存在唯一的拓扑序列。

2）算法实现

int uniquely(MGraph g)
{
  // 表示每个顶点的入度
  int inDegrees[g.numVertices];
  for (int v = 0; v < g.numVertices; v++) {
    for (int i = 0; i < g.numVertices; i++) {
      inDegrees[v] += g.Edge[i][v];
    }
  }

  // 遍历 numVertices 轮，每一轮判断是否 有且仅有 唯一的入度为 0 的顶点
  for (int v = 0; v < g.numVertices; v++) {
    // 入度为 0 的顶点个数
    int count0 = 0;
    // 来记录这一轮入度为 0 的顶点编号
    int targetv = -1;
    for (int i = 0; i < g.numVertices; i++) {
      if (inDegrees[i] == 0) {
        targetv = i;
        count0++;
      }
    }
    // 不存在唯一的拓扑序列
    if (count0 != 1) {
      return 0;
    }
    // 进行入度修改
    for (int j = 0; j < g.numVertices; j++) {
      inDegrees[j] -= g.Edge[targetv][j];
    }
  }
  // 存在唯一的拓扑序列
  return 1;
}

题目详解：
1）散列表 HT 如下：

装填因子等于散列表中已经被填充的位置的数量除以散列表的总长度，因此本题的填装因子是 $7/11$。

2）查找关键字 14 的比较序列：

1. 首先，我们计算 14 的散列地址：$H(14) = (14 \times 3)\%11 = 42\%11 = 9$。
2. 我们查看散列表中索引为 9 的位置，发现那里存储的是关键字 3，此时产生哈希冲突。
3. 由于我们使用的是二次探查，所以计算下一个散列地址：$H_1 = (H_0 + 1^1) \% 11 = (9 + 1) \% 11 = 10$。发现那里存储的是关键字 18，再次遇到哈希冲突。
4. 继续计算下一个散列地址：$H_2 = (H_0 +2^2) \%11 = (9 + 4) \% 11 = 2$，找到关键字 14。

3）查找关键字 8 失败时的哈希地址

1. 计算 8 的散列地址：$H(8) = (8 \times 3) \% 11 = 24 \% 11 = 2$，索引为 2 的位置发现关键字 18，遇到冲突。
2. 使用二次探查，计算下一个散列地址：$H_1 = (H_0 + 1^1) \% 11 = (2 + 1) \% 11 = 3$。索引为 3 的位置存储的是关键字 7，遇到冲突。
3. 我们继续使用二次探查，计算下一个散列地址：$H_2 = (H_0 + 2^2) \% 11 = (2 + 4) \% 11 = 6$，索引为 6 的位置存储的是关键字 9，遇到冲突。
4. 我们继续使用二次探查，计算下一个散列地址：$H_3 = (H_0 + 3^2) \% 11 = (2 + 9) \% 11 = 0$。索引为 0 的位置存储的是关键字 11，遇到冲突。
5. 我们继续使用二次探查，计算下一个散列地址：$H_4 = (H_0 + 4^2) \% 11 = (2 + 16) \% 11 = 7$，发现索引为 7 的位置是空的，确认查找失败，散列地址是 7。

题目详解：
1）从 43 题 (a) 图可以看到，Y 寄存器 rs1 和 rs2 用 5 位表示，所以计算机 M 最多的是 $2^5=32$ 个寄存器。根据指令 R[rd] ← [rs1] << shamt 可知，shamt 表示左移。

shamt：计算机的机器字长是 32 位，所以 shamt 表示左移的最大范围不能超过 32，所以只需要 5bit 就可以表示对应的范围：$\log_{2}32 = 5$。

2）ALUBsrc = O，它的作用是支持 lw 指令和 imm 的偏移（R[rd] ← M[R[rs1]+imm]）

F 的计算如下：

  8765 4321
+ 9876 5432
------------
 11FDB 9753

由于计算机的机器字长是 32 位，所以最高位的 1 舍掉，F = 1FDB 9753H:

OF 是溢出位，我们计算的结果发现确实发生了溢出和进位，所以 OF=1。

CF 是进位位，我们计算的结果发现确实发生了溢出和进位，所以 CF=1。

溢出的判断方法是，最高位进位（异或）次高位，计算过程发现最高位进位，次高位没有进位，所以 CF 是标志判断是否溢出。

3）slli 代表左移指令，s11i 指令的高 12 位（即 IR[31:20]）的最高位为 0，因此无论进行零扩展还是符号扩展，都是在高位补 0，效果等价，因此 Ext 可以是 0 也可以是 1。

4）R[rd] ← M[R[rs1]+imm] 这条指令的意思是，rs1 里的内容加上立即数，等于真正要访问的内存地址。

计算偏移地址，偏移地址可正可负，可以访问现在代码上边的代码，也可以访问下边的。

所以是符号扩展，Ext=1，然后表示加法，所以根据 (b) 图可知 ALUctr=O00。

5）A040 A103H = 1010 0000 0100 0000 1010 0001 0000 0011B，6~0 位 = 0000011，中间的 14~12 位 = 010，最高的 12 位为 A04H。其他两个指令 add 和 slli 的高 12 位都是 000H，所以该指令一定是 lw 指令。

6）A040 A103H = 1010 0000 0100 0000 1010 0001 0000 0011B，6~0 位 = 000 0011，中间的 14~12 位 = 010，最高的 12 位为 A04。imm 是 31~25，也就是 A404 组（注意是符号扩展）

扩展完 1111 1111 1111 1111 1111 1010 0000 0100，十六进制是 FFFF FA04。 rs1 里的内容加上立即数，等于真正要访问的内存地址，R[O1H]=FFFF A2DOH，所以 FFFFFA04 + FFFFA2D0 = lFFFF9CD4H。

题目详解：
1）slli r4,r2,2：这条指令将寄存器 r2 的值左移 2 位，结果存储在寄存器 r4 中。在 C 语言中，这对应于数组索引的计算（即 $i \times 4$，因为每个 int 类型占 4 字节）。因此，我们可以推断出寄存器 r2 存储的是变量 i 的值，即的寄存器编号位 02H。

add r4,r3,r4：这条指令将寄存器 r3 和 r4 的值相加，结果存储在寄存器 r4 中。这对应于计算数组元素的内存地址（即 $\&a[i]$）。因此，我们可以推断出寄存器 r3 存储的是数组 a 的首地址，即 a 的寄存器编号为 03H。