普及组CSP-J初赛单项选择60题训练

    客观题

普及组CSP-J初赛单项选择60题训练

该比赛已结束，您无法在比赛模式下递交该题目。您可以点击“在题库中打开”以普通模式查看和递交本题。

一、选择题（每题 2 分，共 120 分）

第 1 题

在 C++ 中，unsigned int 类型占 32 位，取值范围是 0 到 4294967295。执行以下代码后，输出结果是（）。

unsigned int x = 4294967295u;
cout << x + 1u;

{{ select(1) }}

  • 1
  • 0
  • 4294967296
  • 4294967295

第 2 题

执行以下代码后，输出结果是（）。

int x = 0b101100;
cout << (x & (x - 1)) << " " << (x & -x);

{{ select(2) }}

  • 40 4
  • 44 4
  • 40 8
  • 43 4

第 3 题

执行以下代码后，输出结果是（）。

int a = 5;
int b = a++;
int c = ++a;
cout << a << " " << b << " " << c;

{{ select(3) }}

  • 7 6 7
  • 6 5 7
  • 7 5 7
  • 7 5 6

第 4 题

执行以下代码，当输入为 -7 时，输出结果是（）。

int x;
cin >> x;
cout << x / 2 << " " << x % 2;

{{ select(4) }}

  • -4 1
  • -3 -1
  • -3 1
  • -4 -1

第 5 题

执行以下代码后，输出结果是（）。

string s = "abc";
s = s + s;
cout << s.length() << " " << s.find("bc");

{{ select(5) }}

  • 3 1
  • 6 4
  • 6 2
  • 6 1

第 6 题

在 Linux 终端中，要把当前目录下的源文件 hello.cpp 编译成可执行文件 hello（即执行 ./hello 能够运行），下列命令中不能达到目的的是（）。 {{ select(6) }}

  • g++ hello.cpp -o hello
  • g++ -o hello hello.cpp
  • g++ hello.cpp
  • g++ -O2 hello.cpp -o hello

第 7 题

依次把 1、2、3、4 压入一个初始为空的栈，压入过程中允许随时弹出。下列序列中，不可能作为出栈序列的是（）。 {{ select(7) }}

  • 1 2 3 4
  • 2 3 4 1
  • 3 1 2 4
  • 4 3 2 1

第 8 题

用一个长度为 10 的数组模拟循环队列（下标 0 到 9），front 指向队首元素，rear 指向队尾元素的下一个位置。当 front = 8、rear = 2 时，队列中共有元素（）个。 {{ select(8) }}

  • 3
  • 4
  • 5
  • 6

第 9 题

已知指针 p 指向单链表中某个结点，要把新结点 s 插入到 p 之后，正确的操作是（）。 {{ select(9) }}

  • s->next = p->next; p->next = s;
  • p->next = s; s->next = p;
  • s->next = p; p->next = s;
  • p->next = s->next; s->next = p;

第 10 题

已知一棵二叉树的前序遍历为 ABDEC，中序遍历为 DBEAC，则它的后序遍历为（）。 {{ select(10) }}

  • DECBA
  • DEBCA
  • DEBAC
  • DBECA

第 11 题

一棵含有 1000 个结点的完全二叉树，其高度（根结点为第 1 层）是（）。 {{ select(11) }}

  • 9
  • 10
  • 11
  • 12

第 12 题

用权值 {10, 12, 15, 20, 25} 构造哈夫曼树，该树的带权路径长度（WPL）为（）。 {{ select(12) }}

  • 186
  • 176
  • 196
  • 206

第 13 题

一棵二叉搜索树（BST）的前序遍历为 3 1 2 5 4，则它的后序遍历为（）。 {{ select(13) }}

  • 1 2 4 5 3
  • 1 2 5 4 3
  • 2 1 5 4 3
  • 2 1 4 5 3

第 14 题

一个含有 1000 个顶点、2000 条边的无向图用邻接矩阵存储（有边记为 1，无边记为 0），矩阵中值为 1 的元素共有（）个。 {{ select(14) }}

  • 2000
  • 4000
  • 1000000
  • 2000000

第 15 题

在一个有向图中，所有顶点的入度之和等于（）。 {{ select(15) }}

  • 顶点数
  • 边数的 2 倍
  • 边数
  • 顶点数 × 边数

第 16 题

一棵树中有 5 个度为 3 的结点，其余结点的度都不超过 2，则这棵树中叶子结点（度为 1 的结点）的个数为（）。 {{ select(16) }}

  • 5
  • 6
  • 7
  • 8

第 17 题

一棵二叉树中有 10 个度为 2 的结点和 5 个度为 1 的结点，则这棵二叉树中叶子结点的个数为（）。 {{ select(17) }}

  • 10
  • 11
  • 15
  • 16

第 18 题

判断一个只由字符 ( 和 ) 组成的字符串中括号是否匹配，最合适的数据结构是（）。 {{ select(18) }}

  • 栈
  • 队列
  • 堆
  • 二叉搜索树

第 19 题

用冒泡排序把数组 {6, 1, 5, 2, 4} 排成升序，排序过程中发生元素交换的总次数是（）。 {{ select(19) }}

  • 5
  • 6
  • 7
  • 8

第 20 题

用选择排序把数组 {5, 3, 8, 1} 排成升序（每轮在未排序部分中找最小元素，并与未排序部分的第一个元素交换），第 1 轮结束后数组是（）。 {{ select(20) }}

  • {1, 5, 8, 3}
  • {3, 5, 8, 1}
  • {1, 3, 8, 5}
  • {5, 3, 8, 1}

第 21 题

用插入排序把数组 {3, 1, 2} 排成升序，第 1 趟（把第 2 个元素插入到前面已排好序的部分中）结束后数组是（）。 {{ select(21) }}

  • {1, 3, 2}
  • {1, 2, 3}
  • {3, 1, 2}
  • {2, 1, 3}

第 22 题

若待排序的数据都是 0 到 100 之间的整数，则下列排序算法中通常效率最高的是（）。 {{ select(22) }}

  • 冒泡排序
  • 选择排序
  • 插入排序
  • 计数排序

第 23 题

在长度为 1000 的升序数组中进行二分查找（折半查找），最多需要比较的次数是（）。 {{ select(23) }}

  • 9
  • 10
  • 500
  • 1000

第 24 题

有 1 元、5 元、10 元、20 元四种面值的硬币，每种硬币的数量都足够多。用贪心法找零 36 元，最少需要硬币（）枚。 {{ select(24) }}

  • 3
  • 4
  • 5
  • 6

第 25 题

以下代码用记忆化搜索计算斐波那契数，调用 fib(30) 的时间复杂度是（）。

int f[N];
bool vis[N];

int fib(int n) {
    if (n <= 1) return n;
    if (vis[n]) return f[n];
    vis[n] = true;
    return f[n] = fib(n - 1) + fib(n - 2);
}

{{ select(25) }}

  • O(n²)
  • O(2ⁿ)
  • O(n log n)
  • O(n)

第 26 题

用递归实现汉诺塔问题，把 3 个圆盘从 A 柱借助 B 柱全部移到 C 柱，最少需要移动的次数是（）。 {{ select(26) }}

  • 5
  • 6
  • 7
  • 8

第 27 题

用枚举法（逐一检查每一个整数）求 1 到 n 之间所有能被 3 整除的数，该算法的时间复杂度是（）。 {{ select(27) }}

  • O(n)
  • O(log n)
  • O(1)
  • O(n²)

第 28 题

一个机器人从 (0, 0) 出发，依次执行指令“向右 3 格、向上 2 格、向左 1 格、向下 5 格”，最终所在位置是（）。 {{ select(28) }}

  • (2, 3)
  • (1, -3)
  • (3, -3)
  • (2, -3)

第 29 题

数组 a 从下标 1 开始存储，其前缀和数组 s 定义为 s[0] = 0，s[i] = a[1] + a[2] + … + a[i]。已知 s = {0, 2, 6, 12, 20}，则 a[3] 的值是（）。 {{ select(29) }}

  • 4
  • 8
  • 6
  • 12

第 30 题

下标从 1 开始的数组 a 的区间 [2, 4] 中每个元素都加上 3。若用差分数组 d（d[i] = a[i] - a[i-1]）来实现，正确的操作是（）。 {{ select(30) }}

  • d[2] += 3; d[4] -= 3;
  • d[2] += 3; d[5] -= 3;
  • d[2] -= 3; d[5] += 3;
  • d[2] -= 3; d[4] += 3;

第 31 题

用高精度加法计算两个十进制非负整数之和，若两个数都不超过 100 位（十进制位），则它们的和最多有（）位。 {{ select(31) }}

  • 100
  • 200
  • 101
  • 199

第 32 题

在十进制高精度减法中，若某一位上的被减数小于减数，就需要向高位借 1。借位后，本位应加上（）。 {{ select(32) }}

  • 10
  • 1
  • 9
  • 100

第 33 题

用高精度乘法计算 123 × 45，结果是（）。 {{ select(33) }}

  • 5435
  • 5525
  • 5545
  • 5535

第 34 题

关于图的遍历，下列说法正确的是（）。 {{ select(34) }}

  • 深度优先遍历（DFS）通常借助队列实现
  • 用邻接表存储时，广度优先遍历（BFS）和深度优先遍历（DFS）的时间复杂度都是 O(n + m)，其中 n 为顶点数、m 为边数
  • 无论边权的取值是多少，BFS 都能求出图中任意两点间最短路径的长度
  • 在连通图中，从不同的顶点出发做 DFS，得到的访问序列一定相同

第 35 题

用邻接表存储一个有 n 个顶点、m 条边的无向图（每个顶点对应一个链表头，链表中存放它的所有邻接顶点），所有链表中边结点（链表结点）的总数是（）。 {{ select(35) }}

  • m
  • n + m
  • 2m
  • n × m

第 36 题

在一个只含 0 和 1 的矩阵中，求与格子 (1,1) 相连的 1 的个数（相连指上下左右相邻，连续的一片 1 构成一个连通块），最合适的算法是（）。 {{ select(36) }}

  • Flood Fill（洪水填充，即搜索连通块）
  • 二分查找
  • 冒泡排序
  • 快速幂

第 37 题

一个背包的最大承重为 5。现有三件物品：重量 2、价值 3；重量 3、价值 4；重量 4、价值 5。每件物品最多只能取一次，能获得的最大总价值是（）。 {{ select(37) }}

  • 6
  • 7
  • 8
  • 5

第 38 题

走楼梯时，每次可以上 1 阶或 2 阶。走到第 4 阶共有（）种不同的走法。 {{ select(38) }}

  • 3
  • 4
  • 5
  • 6

第 39 题

将三堆石子（数量分别为 1、2、3）合并成一堆，每次只能合并两堆，合并的代价为这两堆石子数之和。完成合并的最小总代价是（）。 {{ select(39) }}

  • 9
  • 10
  • 11
  • 12

第 40 题

下列排序算法中，属于稳定排序的是（）。 {{ select(40) }}

  • 选择排序
  • 快速排序
  • 堆排序
  • 冒泡排序

第 41 题

二进制数 1011.01 转换为十进制数是（）。 {{ select(41) }}

  • 11.5
  • 11.25
  • 10.75
  • 11.75

第 42 题

在 C++ 中，表达式 5 + 3 * 2 % 4 - 1 的值是（）。 {{ select(42) }}

  • 5
  • 7
  • 6
  • 8

第 43 题

100 以内的最大质数是（）。 {{ select(43) }}

  • 89
  • 91
  • 99
  • 97

第 44 题

用埃氏筛法筛出 1 到 20 之间的所有质数，这些质数共有（）个。 {{ select(44) }}

  • 7
  • 8
  • 9
  • 10

第 45 题

用欧几里得算法（辗转相除法）计算 gcd(1071, 462)，结果是（）。 {{ select(45) }}

  • 3
  • 7
  • 21
  • 231

第 46 题

把 360 分解质因数，结果是（）。 {{ select(46) }}

  • 2³ × 3² × 5
  • 2² × 3² × 5
  • 2³ × 3 × 5²
  • 2² × 3 × 5

第 47 题

从 7 名同学中选 3 名分别担任班长、副班长、学习委员（每人只担任一个职务），不同的安排方案共有（）种。 {{ select(47) }}

  • 21
  • 35
  • 120
  • 210

第 48 题

袋中有 3 个红球、2 个白球，所有球互不相同。从中取出 2 个球，要求两个球颜色不同，共有（）种取法。 {{ select(48) }}

  • 5
  • 6
  • 10
  • 12

第 49 题

杨辉三角的第 0 行只有一个数 1，第 1 行是 1 1，第 2 行是 1 2 1……则第 5 行所有数之和是（）。 {{ select(49) }}

  • 16
  • 25
  • 32
  • 64

第 50 题

从 A 到 B 有 3 条不同的路，从 A 到 C 有 4 条不同的路，从 A 到 D 有 2 条不同的路，且这三组路互不相同。从 A 出发前往 B、C、D 中的某一个，共有（）种走法。 {{ select(50) }}

  • 9
  • 12
  • 24
  • 6

第 51 题

从 A 到 B 有 3 条不同的路，从 B 到 C 有 4 条不同的路。从 A 出发经过 B 到 C，共有（）种走法。 {{ select(51) }}

  • 7
  • 12
  • 24
  • 3

第 52 题

在 C++ 中，字符 '0' 的 ASCII 码的十进制值（即 (int)'0'）是（）。 {{ select(52) }}

  • 0
  • 65
  • 49
  • 48

第 53 题

在 C++ 中，表达式 7 / 2 * 2.0 的值是（）。 {{ select(53) }}

  • 6
  • 7
  • 3.5
  • 6.5

第 54 题

集合 {1, 2, 3, 4} 的非空真子集共有（）个。 {{ select(54) }}

  • 8
  • 15
  • 14
  • 16

第 55 题

十进制数 100 转换为二进制数是（）。 {{ select(55) }}

  • 1100100
  • 1100010
  • 1010100
  • 1110000

第 56 题

十六进制数 1A 转换为十进制数是（）。 {{ select(56) }}

  • 16
  • 26
  • 24
  • 32

第 57 题

十进制数 62 转换为八进制数是（）。 {{ select(57) }}

  • 66
  • 72
  • 76
  • 56

第 58 题

正整数 360 的正因数共有（）个。 {{ select(58) }}

  • 12
  • 18
  • 30
  • 24

第 59 题

若 a 是奇数、b 是偶数，则下列结论一定正确的是（）。 {{ select(59) }}

  • a + b 是奇数
  • a × b 是奇数
  • a − b 是偶数
  • a + b 是质数

第 60 题

执行以下代码后，输出结果是（）。

int x = 0;
if (x != 0 && 10 / x > 1) cout << "yes";
else cout << "no";

{{ select(60) }}

  • yes
  • 0
  • no
  • 程序运行时发生除零错误

普及组CSP-J单项选择强化训练

未参加
状态
已结束
规则
IOI
题目
1
开始于
2026-9-13 19:30
结束于
2026-9-13 21:30
持续时间
2 小时
主持人
参赛人数
15
  1. Language
  2. 兼容模式
  3. 主题
  3. 粤ICP备2025512933号粤公网安备44050702001635号
  60. Worker 0, 65ms
  61. Powered by Hydro v5.0.4 Community