GESP认证C++编程真题解析 | 202603 五级
附上汇总帖：GESP认证C++编程真题解析 | 汇总
单选题
第1题
关于单链表、双链表和循环链表，下列说法正确的是（ ）。
A. 在单链表中，若已知任意结点的指针，则可以在 \(O(1)\) 时间内删除该结点。
B. 循环链表中一定不存在空指针。
C. 在循环双链表中，尾结点的 next 指针一定为 nullptr。
D. 在带头结点的循环单链表中，判定链表是否为空只需判断头结点的 next 是否指向自身。
【答案】：D
【解析】
单链表中若已知任意结点的指针，要删除该结点通常需要知道其前驱结点，找前驱需要从头遍历，时间复杂度为 \(O(n)\)，A错误。
如果是不带头结点的循环单链表且为空表，其头指针即为空指针，B错误。
循环双链表的尾节点的 next 指向头结点，而不是 nullptr，C错误。
第2题
双向循环链表中要在结点 p 之前插入新结点 s （均非空），以下指针操作正确的是（ ）。
A.
s -> next = p;
p -> prev = s;
p -> next = s;
s -> prev = p;
B.
s -> prev = p;
s -> next = p -> next;
p -> next -> prev = s;
p -> next = s;
C.
s -> next = p;
s -> prev = p->prev;
p -> prev -> next = s;
p -> prev = s;
D.
s -> next = p;
s -> prev = nullptr;
p -> prev = s;
【答案】：C
【解析】
在双向链表中结点 p 之前插入结点 s，需要修改四个指针的方向且不能丢失原有的前驱结点引用。首先处理新结点 s 的两端：s->next=p; 以及 s->prev=p->prev;。接着修改原链表中的指针，必须先修改 p 的原前驱结点的后继：p->prev->next=s;，最后修改 p 的前驱指向新结点：p->prev=s;。C正确
第3题
下面函数用“哑结点”统一处理删除单向链表中的头结点与中间结点。横线处应填（ ）。
struct Node{
int val;
Node* next;
Node(int v):val(v),next(nullptr){}
};
Node* eraseAll(Node* head, int x){
Node dummy(0);
dummy.next = head;
Node* cur = &dummy;
while(cur->next){
if(cur->next->val == x){
Node* del = cur->next;
______________________
delete del;
}else cur = cur->next;
}
return dummy.next;
}
A.
cur = cur->next;
B.
cur->next = del->next;
C.
del->next = cur->next;
D.
cur->next = nullptr;
【答案】：B
【解析】
代码中通过建立哨兵结点dummy，并用指针cur遍历链表。当满足条件cur->next->val==x时，表示cur的下一个结点del即为需要被删除的结点。在单链表中删除del，应当将cur结点的next指针越过被删除的结点，直接指向del->next。因此横线处应填入cur->next=del->next;，选项B正确。
第4题
对如下代码实现的欧几里得算法（辗转相除法），执行 gcd(48, 18) 得到的调用序列为（ ）。
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
A.
gcd(48,18) -> gcd(18,12) -> gcd(12,6) -> gcd(6,0)
B.
gcd(48,18) -> gcd(30,18) -> gcd(12,18)
C.
gcd(48,18) -> gcd(18,30) -> gcd(30,6)
D.
gcd(48,18) -> gcd(12,18) -> gcd(6,12)
【答案】：A
【解析】
根据所给的递归代码逻辑，若b!=0，则递归调用gcd(b, a%b)。对于初始调用gcd(48,18)，因为 18 非 0，会执行48%18=12，接着进入gcd(18,12)；同理下一步为18%12=6，进入gcd(12,6)；接着12%6=0，进入gcd(6,0)。当参数b变为 0 时，达到递归终点并返回 6。A正确。
第5题
下面代码实现了欧拉（线性）筛，横线处应填写（ ）。
vector<int> euler_sieve(int n) {
vector<bool> is_composite(n + 1, false);
vector<int> primes;
for (int i = 2; i <= n; i++) {
if (!is_composite[i])
primes.push_back(i);
for (int j = 0; __________________________ && (long long)i * primes[j] <= n; j++) {
is_composite[i * primes[j]] = true;
if (i % primes[j] == 0)
break;
}
}
return primes;
}
A.
j <= n
B.
j < sqrt(n)
C.
j < primes.size()
D.
j < i
【答案】：C
【解析】
线性筛的核心原理是利用每个合数最小的质因子将其筛除。算法中内层循环用于遍历目前已经并发现并收集到primes数组中的质数。数组下标j从0开始，为了防止越界，j必须小于质数数组当前的元素个数，即j<primes.size()。C正确
第6题
埃氏筛中将内层循环从 j = i * i 开始而不是 j = 2*i 的主要原因是（ ）。
vector<int> eratosthenes_sieve(int n) {
vector<bool> is_composite(n + 1, false);
vector<int> primes;
for (int i = 2; i <= n; i++) {
if (is_composite[i]) continue;
primes.push_back(i);
for (long long j = (long long)i * i; j <= n; j += i)
is_composite[j] = true;
}
return primes;
}
A. 因为 2*i 一定不是合数
B. i*i 一定是质数
C. 小于 i*i 的 i 的倍数已被更小质因子筛过
D. 这样可以把时间复杂度降为 \(O(n)\)
【答案】：C
【解析】
在埃氏筛法中，当我们遇到一个素数i时，需要将i的所有倍数标记为合数。对于形如k * i的倍数，必然存在一个更小的素数因子（\(k\) 的素因子）。在算法之前的遍历过程中，这个数肯定已经被那个更小的素数筛去了，所以内层循环直接从i*i开始即可避免重复标记。
第7题
下面程序的运行结果为（ ）。
bool check(int n, int a[], int k, int dist) {
int cnt = 1;
int last = a[0];
for (int i = 1; i < n; i++) {
if (a[i] - last >= dist) {
cnt++;
last = a[i];
}
}
return cnt >= k;
}
int solve(int n, int a[], int k) {
std::sort(a, a + n);
int l = 0;
int r = a[n - 1] - a[0];
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(n, a, k, mid))
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
int a[] = {1, 2, 8, 4, 9};
int n = 5;
int k = 3;
std::cout << solve(n, a, k) << std::endl;
return 0;
}
A. 2
B. 3
C. 4
D. 5
【答案】：B
【解析】
数组排序后为{1,2,4,8,9}，在其中选择 k=3 个元素使得相邻差值最大。当假定最小距离为 3 时，可以选择1、4、8，满足条件；假定距离为 4 时，选了 1 之后只能选择 8，选不够 3 个，不满足条件。因此最大满足要求的距离是 3，选B。
第8题
在升序数组中查找第一个大于等于 x 的位置，下面循环中横线应填（ ）。
int lowerBound(const 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;
}
A.
r = mid;
B.
r = mid - 1;
C.
l = mid;
D.
l = mid + 1;
【答案】：A
【解析】
在二分过程中，如果满足条件a[mid]>=x，说明当前的mid可能是目标位置，或者目标位置在mid的左侧。为了不漏掉这个可能的答案，有边界应该更新为mid，即r=mid;。
第9题
关于递归函数调用，下列说法错误的是（ ）。
A. 递归调用层次过深时，可能会耗尽栈空间导致栈溢出
B. 尾递归函数可以通过编译器优化来避免栈溢出
C. 所有递归函数都可以通过循环结构来改写，从而避免栈溢出
D. 栈溢出发生时，程序会抛出异常并可以继续执行后续代码
【答案】：D
【解析】
每次递归都会消耗系统栈内存，层数过深确实会溢出，A正确。
尾递归优化可以让编辑器重用当前栈帧，避免溢出，B正确。
所有递归问题都可用显式栈配合循环来转换为非递归实现，C正确。
第10题
给定 n 根木头，第 i 根长度为 a[i]。要切成不少于 m 段等长木段，求最大可能长度，则横线上应填写（ ）。
const int MAXN = 100005;
long long a[MAXN];
int n, m;
bool check(long long x){
long long cnt = 0;
for(int i = 1; i <= n; i++){
if(x == 0) return true;
cnt += a[i] / x;
if(cnt >= m) return true;
}
return false;
}
int main(){
cin >> n >> m;
long long mx = 0;
for(int i = 1; i <= n; i++){
cin >> a[i];
mx = max(mx, a[i]);
}
long long l = 1, r = mx;
long long ans = 0;
while(l <= r){
long long mid = l + (r - l) / 2;
if(check(mid)){
ans = mid;
______________________
}else{
______________________
}
}
cout << ans << endl;
return 0;
}
A.
l = mid + 1;
r = mid - 1;
B.
l = mid - 1;
r = mid + 1;
C.
l = mid + 1;
r = mid;
D.
l = mid;
r = mid + 1;
【答案】：A
【解析】
当check(mid)为真时，说明长度为mid是可行的，我们要继续寻找有没有更大的长度。此时记录了最优解ans = mid，转到 [mid + 1，r] ，故应填l = mid + 1;。反之若不可行，则转到[1, mid-1]寻找，填r = mid - 1; ，选A。
第11题
下面代码用分治求“最大连续子段和”，其时间复杂度为（ ）。
int solve(vector<int>& a, int l, int r){
if(l == r) return a[l];
int mid = l + (r - l) / 2;
int left = solve(a, l, mid);
int right = solve(a, mid + 1, r);
int sum = 0, lmax = INT_MIN;
for(int i = mid; i >= l; i--){
sum += a[i];
lmax = max(lmax, sum);
}
sum = 0;
int rmax = INT_MIN;
for(int i = mid + 1; i <= r; i++){
sum += a[i];
rmax = max(rmax, sum);
}
return max({left, right, lmax + rmax});
}
A. \(O(n^2)\)
B. \(O(nlogn)\)
C. \(O(logn)\)
D. \(O(n)\)
【答案】：B
【解析】
该算法采用典型的分治思想，将规模为 \(n\) 的问题划分为两个规模为 \(\displaystyle\frac{n}{2}\) 的子问题进行递归处理。而合并步骤中，为了计算跨越中点的最大子段和，代码向左和向右分别遍历了一遍当前区间的元素，合并操作的时间开销为 \(O(n)\)。因此其递归时间复杂度表达式为\(T(n)=2T(n/2)+O(n)\)，得出该算法的时间复杂度为 \(O(n log n)\)。
第12题
游戏大赛决赛，两组选手分别按得分从小到大排好队，现在要把他们合并成一个有序排行榜。A组： A = {12, 35, 67, 89} ，B组： B = {20, 45, 55, 78} ，下面是归并合并函数的核心循环，横线处应填入（ ）。
int i = 0, j = 0;
vector<int> result;
while (i < A.size() && j < B.size()) {
if (___________________) {
result.push_back(A[i++]);
} else {
result.push_back(B[j++]);
}
}
while (i < A.size()) {
result.push_back(A[i++]);
}
while (j < B.size()) {
result.push_back(B[j++]);
}
A. A[i] >= B[j]
B. A[i] <= B[j]
C. i >= j
D. i <= j
【答案】：B
【解析】
这个是归并排序中合并两个有序数组的经典过程，当遍历时，应当比较A组和B组当前的元素大小，谁小就优先将谁放入结果数组中。
第13题
有 \(n\) 位同学的成绩已经从小到大排好序，现在对它执行下面这段以第一个元素为 pivot 的快速排序，请问此次排序的时间复杂度是（ ）。
void quicksort(vector<int>& a, int l, int r) {
if (l >= r) return;
int pivot = a[l];
int i = l, j = r;
while (i < j) {
while (i < j && a[j] >= pivot) j--;
while (i < j && a[i] <= pivot) i++;
if (i < j) swap(a[i], a[j]);
}
swap(a[l], a[i]);
quicksort(a, l, i - 1);
quicksort(a, i + 1, r);
}
A. \(O(n)\)
B. \(O(nlogn)\)
C. \(O(n^2)\)
D. \(O(logn)\)
【答案】：C
【解析】
在快速排序中，若给定数组已经是有序状态，那么在划分子数组时，会导致划分产生的两个子数组长度极度不平衡，此时递归树退化成了一条链式结构，递归深度达到 \(n\)，每层的时间开销依然是 \(O(n)\)，导致总时间复杂度为 \(O(n^2)\)。
第14题
下面关于排序算法的描述中，不正确的是（ ）。
A. 冒泡排序和插入排序都是稳定的排序算法
B. 快速排序和归并排序都是不稳定的排序算法
C. 冒泡排序和插入排序最好时间复杂度均为 \(O(n)\)
D. 归并排序在最好、最坏和平均三种情况的时间复杂度均为 \(O(nlogn)\)
【答案】：B
【解析】
冒泡和插入排序只在相邻元素间操作，不会改变相等元素的相对位置，所以稳定，A正确。
快速排序在交换的过程会导致不稳定，但归并排序在合并子数组时严格控制了相等元素的插入顺序，是稳定的，B错误。
在数组已有序的最好情况下，冒泡和插入只需扫描一遍，复杂度为 \(O(n)\)，C正确。
归并排序恒定对半分，时间复杂度固定，D正确。
第15题
下面代码实现两个整数除法，其中被除数为一个“大整数”，用字符串表示，除数是一个小整数，用 int 表示，则横线处应该填写（ ）。
int main(){
string s;
int b;
cin >> s >> b;
vector<int> a;
for(char c : s){
a.push_back(c - '0');
}
vector<int> c;
long long rem = 0;
for(int i = 0; i < a.size(); i++){
rem = rem * 10 + a[i];
int q = rem / b;
c.push_back(q);
______________________
}
int pos = 0;
while(pos < c.size() - 1 && c[pos] == 0) pos++;
for(int i = pos; i < c.size(); i++){
cout << c[i];
}
cout << endl;
cout << rem << endl;
return 0;
}
A.
rem /= b;
B.
rem %= b;
C.
rem = b;
D.
rem = q;
【答案】：B
【解析】
这道题使用数组模拟高精度被除数除以单精度除数的过程。在模拟竖式除法的每一位计算中，需要将“上一位的余数乘10再加上当前位数字”构成本次计算的新被除数rem。将新被除数整除单精度除数b得到当前位的商q，而参与下一位运算的则是本次计算剩下的余数，因此通过rem%=b;获取新余数，B正确。
判断题
第1题
有一个存储了 \(n\) 个整数的线性表，分别用数组和单链表两种方式实现。在已知下标（或结点指针）的前提下，数组的随机访问是 \(O(1)\)，而在链表中已知某结点的指针时，在该结点之后插入一个新结点的操作也是 \(O(1)\)。
A. 正确
B. 错误
【答案】：A
【解析】
数组的底层是连续的内存空间，支持通过下标直接进行偏移计算获取元素，因此随机访问的时间复杂度是 \(O(1)\)。在单链表中，仅仅是在已知当前结点p指针的基础上插入新结点s，只需执行s->next=p->next; p->next=s;，操作与链表总长度无关，因此复杂度同样也是 \(O(1)\)。
第2题
若数组 a 已按升序排列，则下面代码可以正确实现 “在 a 中查找第一个大于等于 x 的元素的位置”。
int lowerBound(vector<int>& a,int x){
int l=0, r=a.size();
while(l < r) {
int mid = (l + r) / 2;
if( a[mid] >= x) r = mid;
else l = mid + 1;
}
return l;
}
A. 正确
B. 错误
【答案】：A
【解析】
这是一个典型的求解下界（lower_bound）的二分查找算法实现。当a[mid]>=x成立时，说明目标位置一定不会大于mid，所以应当把右边界收缩至当前位置即r=mid；当a[mid]<x成立时，说明目标一定严格在mid的右边，因此左边界更新为l=mid+1。
第3题
快速排序只要每次都选取中间元素作为枢轴，就一定是稳定排序。
A. 正确
B. 错误
【答案】：B
【解析】
不论选取哪个元素作为枢轴，远距离跳跃式的交换都有可能会打乱原本数值相等的两个元素的先后次序，所以快速排序本质上是不稳定的算法。
第4题
若某算法满足递推式：\(T(n)=2T(n/2)+O(n)\) ，则其时间复杂度为 \(O(nlogn)\)。
A. 正确
B. 错误
【答案】：A
【解析】
算法将规模为 \(n\) 的大问题划分为了2个规模为 \(\displaystyle\frac{n}{2}\) 的子问题进行求解，且在合并或拆分过程花费了额外的 \(O(n)\) 时间。
第5题
在一个数组中，如果两个元素 a[i] 和 a[j] 满足 i < j 且 a[i] > a[j] ，则 a[i] 和 a[j] 是一个逆序对。
下面代码可以正确统计数组 a 区间 [l,r] 内的逆序对总数。
long long cnt=0;
void merge_count(vector<int>& a, int l, int m, int r){
int i = l, j = m + 1;
while(i <= m && j <= r) {
if(a[i] <= a[j]) i++;
else {
cnt += (m - i+ 1);
j++;
}
}
}
A. 正确
B. 错误
【答案】：B
【解析】
给出的代码只进行了归并，没有排序，数组无序时，代码会漏算或重复计算。
第6题
根据唯⼀分解定理，如果⼤于 1 的整数不能被任何不超其平⽅根的质数整除，那么 \(n\) 必定是质数。
A. 正确
B. 错误
【答案】：A
【解析】
如果 \(n\) 没有任何小于等于 \(\sqrt n\) 的质因数来整除它，那就说明 \(n\) 没有除自身外的质因子，因此 \(n\) 一定是质数。
第7题
假设数组 \(a\) 的值域范围是 \(D\)，以下程序的时间复杂度是 \(O(nlogn+nlogD)\)。
bool check(int n, int a[], int k, int dist) {
int cnt = 1;
int last = a[0];
for (int i = 1; i < n; i++) {
if (a[i] - last >= dist) {
cnt++;
last = a[i];
}
}
return cnt >= k;
}
int solve(int n, int a[], int k) {
std::sort(a, a + n);
int l = 0;
int r = a[n - 1] - a[0];
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(n, a, k, mid))
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
int a[] = {1, 2, 8, 4, 9};
int n = 5;
int k = 3;
std::cout << solve(n, a, k) << std::endl;
return 0;
}
A. 正确
B. 错误
【答案】：A
【解析】
二分的时间复杂度是 \(O(logD)\)，在每次判断check(mid)时需要进行一次 \(O(n)\) 复杂度的数组遍历累加。所以总时间复杂度为 \(O(nlogD)\)，加上额外的 \(O(nlogn)\) 排序，得到 \(O(nlogn+nlogD)\)。
第8题
若一个问题满足最优子结构性质，则一定可以用贪心算法得到最优解。
A. 正确
B. 错误
【答案】：B
【解析】
要保证贪心算法真正可以得出全局最优解，该问题还必须满足更严格的“贪心选择性质”，也就是在当前步骤做的每一步局部最优选择，未来一定能导向最终的全局最优。缺乏贪心选择性质时，只有使用动态规划去全局推导才是安全的。
第9题
线性筛相比埃氏筛的核心改进在于：埃氏筛中一个合数可能被多个质数重复标记，线性筛通过"每个合数只被其最大质因子筛去"的策略，保证每个合数恰好被标记一次，从而实现 \(O(n)\) 的时间复杂度。
A. 正确
B. 错误
【答案】：B
【解析】
线性筛的正确实现策略是确保“每个合数只被其最小质因子筛除”而不是最大质因子。
第10题
任何递归程序都可以改写为等价的非递归程序，但改写后的非递归程序一定需要显式地使用栈来模拟递归调用过程。
A. 正确
B. 错误
【答案】：B
【解析】
递归程序都可以改写为非递归程序，但不一定必须使用“显式栈”，还可以用循环或数学递推等形式。
浙公网安备 33010602011771号