CCF GESP C++ 五级 (2026 年 06 月)

一、单选题（每题 2 分，共 30 分）

1. 假设 head != nullptr ，下⾯是实现单向循环链表在头节点后插⼊新节点的代码，横线处应填⼊（ ） 5 A. B. C. D.

newNode->next = head->next;
head = newNode;

{{ select(1) }}

2. 下⾯代码遍历并输出⼀个循环单链表，其中 head 指向链表的第⼀个节点，横线处应填⼊的是（ ） 5 A. B. C. D.

for (; p; p = p->next) {
cout << p->val << " ";
}

{{ select(2) }}

3. 双链表结点定义如下，若要删除双链表中的中间结点（⾮⾸尾节点） p ，下⾯写法正确的是（ ） A. B. C. D.

p->next->next = p->prev;
p->prev->prev = p->next;
delete p;

{{ select(3) }}

4. 使⽤如下欧⼏⾥得算法求 gcd(105, 45) 时，函数 gcd(a, b) 的递归调⽤序列正确的是（ ）

int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}

{{ select(4) }}

• gcd(105, 45) -> gcd(45, 60) -> gcd(60, 15) -> gcd(15, 0)
• gcd(105, 45) -> gcd(45, 15) -> gcd(15, 0)
• gcd(105, 45) -> gcd(60, 45) -> gcd(15, 45)
• gcd(105, 45) -> gcd(15, 45) -> gcd(15, 0)

5. 下⾯代码实现线性筛（欧拉筛），以筛选出 以内的所有素数。横线处的代码应为（ ） 4 7

for (int i = 2; i <= n; ++i) {
if (is_prime[i]) {
primes.push_back(i);
}
for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) {
is_prime[i * primes[j]] = false;
if (________________) break; // 在此处填入代码
}
}
return primes;
}

{{ select(5) }}

• i % primes[j] == 0
• primes[j] % i == 0
• i % primes[j] != 0
• i == primes[j]

6. 下⾯关于埃⽒筛法的说法正确的是（ ）

{{ select(6) }}

• 每个合数只会被筛掉⼀次
• 从每个素数出发，把它的倍数标记为合数
• 只能判断⼀个数是不是偶数
• 不能求出素数表

7. 下⾯代码实现了计算 的快速幂算法，该算法体现的编程思想是（ ）

long long power(long long x, int n) {
if (n == 0) return 1;
long long res = power(x, n / 2);
if (n % 2 == 0) return res * res;
else return res * res * x;
}

{{ select(7) }}

• 枚举
• 贪⼼
• 分治
• 模拟

8. 下⾯代码⽤于统计 n 中因⼦ 2 出现了多少次。若 n = 40 ，输出是（ ）

int n = 40;
int cnt = 0;
while (n % 2 == 0) {
cnt++;
n /= 2;
}
cout << cnt;

{{ select(8) }}

• 1
• 2
• 3
• 4

9. 在⼀个有序数组中查找第⼀个⼤于或等于 x 的元素位置，横线处应填写（ ）

int lowerBound(vector<int>& a, int x) {
int l = 0, r = a.size();
while (l < r) {
int mid = l + (r - l) / 2;
if (a[mid] >= x) ________________; // 在此处填入代码
else l = mid + 1;
}
return l;
}

{{ select(9) }}

• r = mid + 1
• r = mid - 1
• r = mid
• l = mid

10. 有若⼲根⽊头，长度存于 wood 。每切⼀⼑可以把⼀段⽊头分成两段。函数 check(wood, K, x) 返回： ）。 4

for (int len : wood) r = max(r, len);
while (l < r) {
int mid = l + (r - l) / 2;
if (check(wood, K, mid))
________________; // 在此处填入代码
else l = mid + 1;
}
return l;
}

{{ select(10) }}

• r = mid + 1
• r = mid
• l = mid
• r = mid - 1

11. 下⾯代码段实现了快速排序的划分操作（以⾸元素为基准），横线处代码应填⼊（ ）

int partition(vector<int>& arr, int low, int high) {
int pivot = arr[low];
int i = low, j = high;
while (i < j) {
while (i < j && arr[j] >= pivot) j--;
while (i < j && arr[i] <= pivot) i++;
if (i < j) swap(arr[i], arr[j]);
}
________________; // 在此处填入代码
return i;
}

{{ select(11) }}

• swap(arr[low], arr[high])
• swap(arr[low], arr[i])
• swap(arr[i], arr[high])
• arr[i] = pivot

12. 下⾯哪句话最符合归并排序的思想？（ ）

{{ select(12) }}

• 每次选择最⼩元素放到前⾯
• 将数组分成两半分别排序，再合并两个有序部分
• 相邻元素两两交换
• 从左到右把元素插⼊有序区

13. 在对长度为 （ ）的数组进⾏归并排序的过程中， mergeArray 函数（合并两个有序⼦数组的操作） 被调⽤的次数是（ ）。 2 5 10 18 22 26 31 36 38 41 A. B. C. D.

mergeArray(left, mid, right);
}

{{ select(13) }}

14. ⼩杨在学校义卖会上负责打包“零⾷盲盒”。每个盲盒重量不同，快递盒最多承重 limit 克，每个快递盒最 多装两个盲盒。为了尽量少⽤快递盒，他采⽤如下策略： （1）每次把最轻的盲盒和最重的盲盒尝试放在⼀起； （2）如果两者重量之和不超过 limit ，就⼀起装； （3）否则，只能让最重的盲盒单独装⼀盒。 下⾯代码⽤于计算最少需要多少个快递盒，则横线处应填⼊的是（ ）。 3 6 15

return boxes;
}

{{ select(14) }}

• l++;
• r--;
• boxes--;

15. ⾼精度减法中，假设两个⾼精度数按低位在前存储，且已经保证被减数不⼩于减数。下⾯处理借位逻辑代 码中横线处应填⼊（ ）。

if (a[i] < b[i]) {
a[i + 1]--;
________________;
}
t = a[i] - b[i];

{{ select(15) }}

• a[i] += 10
• a[i] -= 10
• b[i] += 10
• a[i] = a[i+1] + 10

二、判断题（每题 2 分，共 20 分）

1. 数组的存储空间在物理上通常是连续的，⽽链表的结点可以存储在不连续的内存空间中

{{ select(16) }}

• 对
• 错

2. 带哨兵头尾节点的双向循环链表，在表头插⼊节点 p ，以下四步操作⽆论什么顺序执⾏结果都正确

{{ select(17) }}

• 对
• 错

3. 对任意正整数 a 、 b ，以下两种写法的 gcd 函数返回值完全相同 4

{{ select(18) }}

• 对
• 错

4. 在归并排序的合并操作中，如下代码⽚段可以正确地将两个已排序的⼦数组 L 和 R 合并回原数组 arr 中。 5

{{ select(19) }}

• 对
• 错

5. 分治法通常将⼀个规模较⼤的问题拆分为若⼲个规模较⼩、结构相似的⼦问题，分别求解后再合并⼦问题的 结果。

{{ select(20) }}

• 对
• 错

6. 贪⼼算法只要每⼀步选择当前最优解，就⼀定能得到全局最优解

{{ select(21) }}

• 对
• 错

7. ⼆分查找不仅可以应⽤于有序数组，也可以在不增加时间复杂度的情况下应⽤于有序的单链表，因为链表也 ⽀持 时间内的随机访问。

{{ select(22) }}

• 对
• 错

8. 以下函数 f1 的时间复杂度⽐函数 f2 的更⾼ 4

{{ select(23) }}

• 对
• 错

9. 唯⼀分解定理表明，任何⼀个⼤于 的⾃然数都可以唯⼀地分解为若⼲个质数的乘积，如果不考虑质因数的 顺序，这种分解⽅式是唯⼀的。

{{ select(24) }}

• 对
• 错

10. 归并排序和快速排序在平均情况下的时间复杂度均为 。但在稳定性⽅⾯，归并排序通常是不稳定 的，⽽快速排序是稳定的。

{{ select(25) }}

• 对
• 错