GESP 客观题评测系统

试卷解析 · 理解每一步

普及组 CSP-J 2026 初赛模拟卷 2

CSPJ-2026-R1-Mock-2

试卷解析总览,可直接查看每题答案与解析。

一、单项选择题

(共 15 题,每题 2 分,共计 30 分;每题有且仅有一个正确选项)

第 1 题(单选题,2 分)

在 C++ 中使用 `vector` 容器前,通常需要包含的头文件是( )。

A.
`<cmath>`
B.
`<queue>`
C.
`<vector>`
D.
`<cstdio>`

正确答案C

解析详情
答案 CC++ vector
思路与推导
  1. `vector` 容器声明在标准头文件 `<vector>` 中。

第 2 题(单选题,2 分)

表达式 `12 ^ 10` 的十进制结果为( )。

A.
2
B.
4
C.
6
D.
22

正确答案C

解析详情
答案 C按位异或
思路与推导
  1. 12 的二进制为 1100,10 为 1010,逐位异或得到 0110,即十进制 6。

第 3 题(单选题,2 分)

内存地址最重要的特点是( )。

A.
随机性
B.
唯一性
C.
顺序性
D.
连续性

正确答案B

解析详情
答案 B内存编址
思路与推导
  1. 内存的每个可寻址单元都必须有唯一地址,处理器才能准确读写目标位置;连续性会因分页等机制而变化,不是最根本属性。

第 4 题(单选题,2 分)

执行下面代码后,`x` 的值为( )。

int x = 1;
switch (x) {
case 1: x += 2;
case 3: x *= 2; break;
default: x = 0;
}
A.
1
B.
2
C.
3
D.
6

正确答案D

解析详情
答案 Dswitch 贯穿执行
思路与推导
  1. 进入 `case 1` 后先把 x 改为 3;由于没有 break,继续执行 `case 3`,得到 6。

第 5 题(单选题,2 分)

二进制数 (101101)2(101101)_2 对应的十进制数是( )。

A.
45
B.
41
C.
53
D.
61

正确答案A

解析详情
答案 A进制转换
思路与推导
  1. (101101)2=32+8+4+1=45(101101)_2=32+8+4+1=45。

第 6 题(单选题,2 分)

CPU 中( )相当于运算器中的一个存储单元,它的存取速度比存储器快得多。

A.
存放器
B.
辅存
C.
主存
D.
寄存器

正确答案D

解析详情
答案 DCPU 组成
思路与推导
  1. 寄存器位于 CPU 内部,用来暂存参与运算的数据、地址和状态,访问速度远高于主存和辅存,因此相当于运算器中的高速存储单元。

第 7 题(单选题,2 分)

执行 `int a[5]={1,2,3,4,5}; cout << a[1]+a[3];` 后输出( )。

A.
6
B.
4
C.
8
D.
10

正确答案A

解析详情
答案 A数组下标
思路与推导
  1. 数组下标从 0 开始,`a[1]=2`、`a[3]=4`,两者之和为 6。

第 8 题(单选题,2 分)

一棵有 15 个结点的满二叉树共有( )个叶结点。

A.
4
B.
7
C.
8
D.
15

正确答案C

解析详情
答案 C满二叉树
思路与推导
  1. 满二叉树中叶结点数比内部结点数多 1;15 个结点对应 7 个内部结点和 8 个叶结点。

第 9 题(单选题,2 分)

计算机中的数有浮点与定点两种,其中用浮点表示的数通常由( )组成。

A.
指数与基数
B.
尾数与小数
C.
阶码与尾数
D.
整数与小数

正确答案C

解析详情
答案 C浮点数表示
思路与推导
  1. 浮点数类似科学记数法,由表示有效数字的尾数和表示缩放次数的阶码组成,数值可写成尾数乘以基数的阶码次幂。

第 10 题(单选题,2 分)

一个 8 位有符号整数采用二进制补码表示时,其取值范围是( )。

A.
−128∼127-128\sim127
B.
−127∼127-127\sim127
C.
0∼2550\sim255
D.
−128∼128-128\sim128

正确答案A

解析详情
答案 A二进制补码
思路与推导
  1. 8 位补码有 1 位符号及 7 位数值信息,范围为 −27-2^7 到 27−12^7-1,即 -128 到 127。

第 11 题(单选题,2 分)

下列叙述中,正确的是( )。

A.
线性表的线性存储结构优于链表存储结构
B.
队列的操作方式是先进后出
C.
栈的操作方式是先进先出
D.
二维数组逻辑上可以理解为它的每个数据元素为一个线性表的线性表

正确答案D

解析详情
答案 D线性结构
思路与推导
  1. 二维数组可看成元素本身又是线性表的线性表。队列是先进先出,栈是后进先出;顺序表和链表各有优缺点,不能笼统判定前者更优。

第 12 题(单选题,2 分)

用某种排序方法对线性表 25, 84, 21, 47, 15, 27, 68, 35, 20 进行排序,节点变化如下:

(1) 25, 84, 21, 47, 15, 27, 68, 35, 20;
(2) 20, 15, 21, 25, 47, 27, 68, 35, 84;
(3) 15, 20, 21, 25, 35, 27, 47, 68, 84;
(4) 15, 20, 21, 25, 27, 35, 47, 68, 84。

那么,排序方法是( )。

A.
选择排序
B.
希尔排序
C.
合并排序
D.
快速排序

正确答案D

解析详情
答案 D快速排序
思路与推导
  1. 第一次变化后,枢轴 25 已就位,左侧元素不大于 25、右侧元素不小于 25;后续又分别对子区间做同样划分,符合快速排序的分区过程。

第 13 题(单选题,2 分)

如果某二叉树的前序遍历序列为 STUWV,中序遍历序列为 UWTVS,那么该二叉树的后序遍历序列是( )。

A.
WUVTS
B.
UWVTS
C.
VWUTS
D.
WUTSV

正确答案A

解析详情
答案 A二叉树遍历
思路与推导
  1. 前序首节点 S 是根,中序中 S 左侧全为左子树;左子树根为 T,其左子树由 U、W 构成,右子树为 V。按左、右、根得到后序 WUVTS。

第 14 题(单选题,2 分)

下列关于数据结构的叙述中,正确的是( )。

A.
顺序存储方式的优点是存储密度大,且插入、删除运算效率高
B.
链表中的每一个节点都包含一个非空指针项
C.
包含 nn 个节点的二叉排序树的最大检索长度为 log⁡2n\log_2 n
D.
将一棵树转换为二叉树后,根节点没有右子树

正确答案D

解析详情
答案 D树的孩子兄弟表示法
思路与推导
  1. 树转换为二叉树时,左指针指向第一个孩子,右指针指向下一个兄弟。根节点没有兄弟,因此转换后的根节点没有右子树。

第 15 题(单选题,2 分)

表达式 (1+34)×5−56/7(1+34)\times 5-56/7 的后缀表达式为( )。

A.
`1 34 + 5 56 7 - * /`
B.
`- * + 1 34 5 / 56 7`
C.
`1 34 + 5 * 56 7 / -`
D.
`1 34 5 * + 56 7 /`

正确答案C

解析详情
答案 C中缀转后缀
思路与推导
  1. 先把 (1+34)(1+34) 写成 `1 34 +`,再与 5 相乘得到 `1 34 + 5 *`;56/756/7 写成 `56 7 /`,最后执行减法,得到 `1 34 + 5 * 56 7 / -`。

二、阅读程序(1)

程序输入不超过数组或字符串定义的范围;判断题正确填 ✓,错误填 ✗;除特殊说明外,判断题每题 2 分,选择题每题 3 分。

 1 | #include <iostream>
 2 | using namespace std;
 3 | void hanoi(int n, char a, char b, char c) {
 4 |     if (n == 1)
 5 |         cout << n << "_" << a << "_" << c << endl;
 6 |     else {
 7 |         hanoi(n - 1, a, c, b);
 8 |         cout << n << "_" << a << "_" << c << endl;
 9 |         hanoi(n - 1, b, a, c);
10 |     }
11 | }
12 | int main() {
13 |     int n;
14 |     cin >> n;
15 |     hanoi(n, 'A', 'B', 'C');
16 |     return 0;
17 | }

第 16 题(判断题,2 分)

当 n≥0n \geq 0 时,程序不会出现死循环。

正确答案错误

解析详情
答案 错误递归终止条件
思路与推导
  1. 当 n=0n=0 时不满足 `n == 1`,程序会递归调用 `hanoi(-1, ...)`,之后参数继续减小,无法到达终止条件。

第 17 题(判断题,2 分)

输出共有 2n2^n 行。

正确答案错误

解析详情
答案 错误递归计数
思路与推导
  1. 设输出行数为 T(n)T(n),则 T(n)=2T(n−1)+1T(n)=2T(n-1)+1 且 T(1)=1T(1)=1,解得 T(n)=2n−1T(n)=2^n-1,并非 2n2^n。

第 18 题(判断题,2 分)

当 n>0n>0 时,将第 4 行的 `==` 改为 `<=`,程序输出结果必定不变。

正确答案正确

解析详情
答案 正确递归边界
思路与推导
  1. 在 n>0n>0 的前提下,递归参数从 nn 逐级减到 1,不会出现 0 或负数,因此把 `n == 1` 改成 `n <= 1` 仍在同一层终止,输出不变。

第 19 题(判断题,2 分)

将第 5 行的 `n` 改为 `1`,程序输出结果必定不变。

正确答案正确

解析详情
答案 正确递归终止分支
思路与推导
  1. 第 5 行只在 n == 1 的分支中执行,因此执行到这一行时 n 必然等于 1。把这里输出的 n 改成常量 1 不会改变任何输出。

第 20 题(单选题,3 分)

此程序的时间复杂度是( )。

A.
O(n)O(n)
B.
O(n2)O(n^2)
C.
O(n3)O(n^3)
D.
O(2n)O(2^n)

正确答案D

解析详情
答案 D递归时间复杂度
思路与推导
  1. 每个规模为 nn 的调用产生两个规模为 n−1n-1 的调用,并做常数次输出,递推式为 T(n)=2T(n−1)+O(1)T(n)=2T(n-1)+O(1),所以时间复杂度为 O(2n)O(2^n)。

第 21 题(单选题,3 分)

若要求输出不超过 15 行,则下列 nn 值中( )是合法的。

A.
00
B.
44
C.
55
D.
66

正确答案B

解析详情
答案 B汉诺塔输出次数
思路与推导
  1. 正整数 nn 时输出 2n−12^n-1 行。n=4n=4 恰好输出 15 行;n=5,6n=5,6 均超过 15,而 n=0n=0 会因缺少终止条件无限递归。

二、阅读程序(2)

 1 | #include <cstdio>
 2 | #define N 1005
 3 | using namespace std;
 4 | int num[N];
 5 | int main() {
 6 |     int a1 = 1, n, x;
 7 |     scanf("%d", &n);
 8 |     num[1] = 1;
 9 |     for (int i = 1; i <= n; ++i) {
10 |         x = 0;
11 |         for (int j = 1; j <= a1; ++j) {
12 |             num[j] = num[j] * 5 + x;
13 |             x = num[j] / 10;
14 |             num[j] %= 10;
15 |         }
16 |         if (x > 0) num[++a1] = x;
17 |     }
18 |     printf("0.");
19 |     for (int i = a1; i < n; ++i) putchar('0');
20 |     for (int i = a1; i >= 1; i--) printf("%d", num[i]);
21 |     putchar('\n');
22 |     return 0;
23 | }

第 22 题(判断题,2 分)

程序输出的是 0.5n0.5^n 的值。

正确答案正确

解析详情
答案 正确高精度小数
思路与推导
  1. 数组保存 5n5^n 的十进制数字,程序在前面输出 0. 并补足到 nn 位小数,因此整体数值为 5n/10n=(0.5)n5^n/10^n=(0.5)^n。

第 23 题(判断题,2 分)

第 19 行和第 20 行两个 `for` 循环中声明的变量 `i` 属于同一个局部变量。( )

正确答案错误

解析详情
答案 错误局部变量作用域
思路与推导
  1. 两个 `for` 循环都在循环头中重新声明 `int i`,每个变量的作用域仅覆盖各自循环,因此不是同一个局部变量。

第 24 题(判断题,2 分)

程序运行过程中,数组有效数字位 `num[1]` 到 `num[a1]` 始终都在 0 到 9 之间。( )

正确答案正确

解析详情
答案 正确高精度数字表示
思路与推导
  1. 每次乘法后先用 `/10` 提取进位,再对当前位 `%10`,新产生的最高位也是一位十进制数,因此所有有效位始终在 0 到 9 之间。

第 25 题(判断题,2 分)

程序输出的是一个小数,且小数末尾可能有多余的 0。

正确答案错误

解析详情
答案 错误有限小数表示
思路与推导
  1. 程序输出 (1/2)n=5n/10n(1/2)^n=5^n/10^n 的恰好 nn 位小数。5n5^n 不含因子 2,十进制末位为 5,不会产生多余的末尾 0。

第 26 题(单选题,3 分)

此程序的时间复杂度是( )。

A.
O(n)O(n)
B.
O(n2)O(n^2)
C.
O(n3)O(n^3)
D.
O(nlog⁡n)O(n\log n)

正确答案B

解析详情
答案 B高精度算法复杂度
思路与推导
  1. 外层循环执行 nn 次,第 ii 次需要处理 5i5^i 的全部十进制位,其位数与 ii 成正比;总工作量为 1+2+⋯+n=O(n2)1+2+\cdots+n=O(n^2)。

第 27 题(单选题,3 分)

若 n=3n=3,则输出为( )。

A.
88
B.
0.1250.125
C.
0.80.8
D.
125125

正确答案B

解析详情
答案 B程序模拟
思路与推导
  1. n=3n=3 时数组得到 53=1255^3=125,程序在其前面输出 `0.`,且总共保留 3 位小数,所以最终输出 `0.125`。

二、阅读程序(3)

 1 | #include <iostream>
 2 | using namespace std;
 3 | int l, n, m, a[50005], ans;
 4 | bool check(int dis) {
 5 |     int count = 0, last = 0;
 6 |     for (int i = 1; i <= n + 1; i++)
 7 |         if (a[i] - last < dis) count++;
 8 |         else last = a[i];
 9 |     if (count > m) return 0;
10 |     return 1;
11 | }
12 |
13 | int main() {
14 |     // 输入保证 l, n, m, a[i] 是正整数,且 a[i] 严格递增
15 |     cin >> l >> n >> m;
16 |     for (int i = 1; i <= n; i++) cin >> a[i];
17 |     a[n + 1] = l;
18 |     int fl = 0, fr = l;
19 |     while (fl <= fr) {
20 |         int mid = (fl + fr) / 2;
21 |         if (check(mid)) fl = mid + 1, ans = mid;
22 |         else fr = mid - 1;
23 |     }
24 |     cout << ans << endl;
25 |     return 0;
26 | }

第 28 题(判断题,2 分)

将 `main()` 函数中 `while` 之前的 `fl = 0` 改为 `fl = 1`,程序输出结果必定不变。

正确答案正确

解析详情
答案 正确二分答案边界
思路与推导
  1. 位置均为严格递增的正整数,合法方案的最小距离至少为 1,因此距离 0 无需成为最终答案;把二分下界从 0 改为 1 不影响最大可行距离。

第 29 题(判断题,2 分)

程序结束前,必有 `fl > fr`。

正确答案正确

解析详情
答案 正确二分循环不变量
思路与推导
  1. 循环条件是 `fl <= fr`,每轮都会令 `fl = mid + 1` 或 `fr = mid - 1`。循环结束的唯一条件就是 `fl > fr`。

第 30 题(判断题,2 分)

若主函数中执行 `check(mid)` 返回 1,则最终的 `ans` 小于或等于此时的 `mid`。

正确答案错误

解析详情
答案 错误二分答案单调性
思路与推导
  1. 当 `check(mid)` 返回 1 时,程序立即令 `ans = mid`,之后还会向更大的距离继续搜索,所以最终 `ans` 必定大于等于该 `mid`,而不是小于等于。

第 31 题(单选题,3 分)

此程序的时间复杂度是( )。

A.
O(n2)O(n^2)
B.
O(nl)O(nl)
C.
O(nlog⁡l)O(n\log l)
D.
O(nlog⁡n)O(n\log n)

正确答案C

解析详情
答案 C二分答案复杂度
思路与推导
  1. `check` 顺序扫描 n+1n+1 个位置,耗时 O(n)O(n);二分区间为 [0,l][0,l],执行 O(log⁡l)O(\log l) 次,因此总复杂度为 O(nlog⁡l)O(n\log l)。

第 32 题(单选题,3 分)

若输入如下,则输出为( )。

25 5 2
2 11 14 17 21
A.
33
B.
44
C.
55
D.
66

正确答案B

解析详情
答案 B贪心判定与二分答案
思路与推导
  1. 距离 4 时可移除位置 2 和 14,保留 0、11、17、21、25,相邻距离均不少于 4。距离 5 时贪心至少需移除 2、14、21 三块石头,超过 m=2m=2,故答案为 4。

三、完善程序(1)无权图最短路

(无权图最短路)给定一个 nn 个顶点、mm 条边的无向图以及起点 ss,使用 BFS 求起点到每个顶点的最少边数。不可达顶点的距离保持为 -1。

1 | #include <iostream>
2 | #include <queue>
3 | #include <vector>
4 | using namespace std;
5 | int main() {
6 |     int n, m, s;
7 |     cin >> n >> m >> s;
8 |     vector<vector<int>> g(n + 1);
9 |     for (int i = 0; i < m; ++i) {
10 |         int u, v;
11 |         cin >> u >> v;
12 |         g[u].push_back(v);
13 |         g[v].push_back(u);
14 |     }
15 |     vector<int> dist(n + 1, -1);
16 |     queue<int> q;
17 |     ① = 0;
18 |     ②;
19 |     while (!q.empty()) {
20 |         int u = q.front();
21 |         ③;
22 |         for (int v : g[u]) {
23 |             if (④) {
24 |                 ⑤;
25 |                 q.push(v);
26 |             }
27 |         }
28 |     }
29 |     for (int i = 1; i <= n; ++i)
30 |         cout << dist[i] << (i == n ? '\n' : ' ');
31 |     return 0;
32 | }

第 33 题(单选题,3 分)

① 处应填( )。

A.
dist[1]
B.
dist[n]
C.
dist[s]
D.
dist[0]

正确答案C

解析详情
答案 CBFS 起点初始化
思路与推导
  1. 起点为 s,起点到自身距离为 0,因此设置 `dist[s]=0`。

第 34 题(单选题,3 分)

② 处应填( )。

A.
q.push(s)
B.
q.pop()
C.
q.push(n)
D.
q.front()

正确答案A

解析详情
答案 ABFS 队列初始化
思路与推导
  1. 搜索开始前应把起点 s 放入队列。

第 35 题(单选题,3 分)

③ 处应填( )。

A.
q.pop()
B.
q.push(u)
C.
q.back()
D.
dist[u] = -1

正确答案A

解析详情
答案 ABFS 出队
思路与推导
  1. 读取队首顶点后要执行 `q.pop()` 将其移除,否则会反复处理同一顶点。

第 36 题(单选题,3 分)

④ 处应填( )。

A.
dist[v] == 0
B.
dist[v] == -1
C.
v == s
D.
dist[u] == -1

正确答案B

解析详情
答案 BBFS 访问标记
思路与推导
  1. 距离初值 -1 表示尚未访问,只应把未访问顶点加入队列。

第 37 题(单选题,3 分)

⑤ 处应填( )。

A.
dist[v] = 0
B.
dist[v] = dist[u]
C.
dist[v] = dist[u] + 1
D.
dist[u] = dist[v] + 1

正确答案C

解析详情
答案 C无权图最短路
思路与推导
  1. 从 u 沿一条边到 v,距离增加 1,因此首次访问 v 时设置 `dist[v]=dist[u]+1`。

三、完善程序(2)0-1 背包

(0-1 背包)有 nn 件物品,背包容量为 VV。第 ii 件物品重量为 wiw_i、价值为 cic_i,每件物品最多选择一次,求不超过容量时的最大总价值。

1 | #include <algorithm>
2 | #include <iostream>
3 | #include <vector>
4 | using namespace std;
5 | int main() {
6 |     int n, V;
7 |     cin >> n >> V;
8 |     vector<int> dp(V + 1, ①);
9 |     for (int i = 1; i <= ②; ++i) {
10 |         int w, c;
11 |         cin >> w >> c;
12 |         for (int j = V; ③; --j)
13 |             dp[j] = ④;
14 |     }
15 |     cout << ⑤ << '\n';
16 |     return 0;
17 | }

第 38 题(单选题,3 分)

① 处应填( )。

A.
0
B.
-1
C.
V
D.
n

正确答案A

解析详情
答案 A0-1 背包初值
思路与推导
  1. 不选择任何物品时,各容量下的最大价值初始为 0。

第 39 题(单选题,3 分)

② 处应填( )。

A.
n
B.
V
C.
n + V
D.
w

正确答案A

解析详情
答案 A物品枚举
思路与推导
  1. 共有 n 件物品,外层循环应枚举 1 到 n。

第 40 题(单选题,3 分)

③ 处应填( )。

A.
j <= V
B.
j > 0
C.
j >= w
D.
j >= c

正确答案C

解析详情
答案 C0-1 背包容量方向
思路与推导
  1. 容量从 V 倒序枚举到当前物品重量 w,条件为 `j>=w`。

第 41 题(单选题,3 分)

④ 处应填( )。

A.
dp[j - w]
B.
dp[j] + c
C.
min(dp[j], dp[j - w] + c)
D.
max(dp[j], dp[j - w] + c)

正确答案D

解析详情
答案 D0-1 背包转移
思路与推导
  1. 容量 j 的最优值要在不选当前物品的 `dp[j]` 与选择后的 `dp[j-w]+c` 之间取最大。

第 42 题(单选题,3 分)

⑤ 处应填( )。

A.
dp[n]
B.
dp[V]
C.
V
D.
dp[0]

正确答案B

解析详情
答案 B背包答案
思路与推导
  1. `dp[j]` 表示容量不超过 j 时的最大价值,目标容量为 V,因此输出 `dp[V]`。