理论卷2026年3月GESP等级认证(C++) · 五级

GESP C++ 5级 2026.03

满分 100 · 及格 60 · 时长 60 分钟 · 共 27 题 (单选15 / 判断10 / 编程题2)

试卷阅览 · 免费预览前 10 题 · 交卷后可查看答案与解析

单选题号 #10755

分值 2

关于单链表、双链表和循环链表，下列说法正确的是（）

在单链表中，若已知任意结点的指针，则可以在 $O(1)$ 时间内删除该结点。

循环链表中一定不存在空指针。

在循环双链表中，尾结点的 next 指针一定为 nullptr。

在带头结点的循环单链表中，判定链表是否为空只需判断头结点的 next 是否指向自身。

单选题号 #10756

分值 2

双向循环链表中要在结点 $p$ 之前插入新结点 $s$ （均非空），以下指针操作正确的是（）。

s->next = p;
p->prev = s; 
q->next = s; 
s->prev = q;

s->prev = p;
s->next = p->next;
p->next->prev = s;
p->next = s;

s->next = p;
s->prev = p->prev;
p->prev->next = s;
p->prev = s;

s->next = p;
s->prev = nullptr;
p->prev = s;

单选题号 #10757

分值 2

下面函数用“哑结点”统一处理删除单向链表中的头结点与中间结点。横线处应填（）。

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;
}

cur = cur->next;

cur->next = del->next;

del->next = cur->next;

cur->next = nullptr;

单选题号 #10758

分值 2

对如下代码实现的欧几里得算法（辗转相除法），执行 $gcd(48, 18)$ 得到的调用序列为（）。

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

$gcd(48, 18) \rightarrow gcd(18, 12) \rightarrow gcd(12, 6) \rightarrow gcd(6, 0)$

$gcd(48, 18) \rightarrow gcd(30, 18) \rightarrow gcd(12, 18)$

$gcd(48, 18) \rightarrow gcd(18, 30) \rightarrow gcd(30, 6)$

$gcd(48, 18) \rightarrow gcd(12, 18) \rightarrow gcd(6, 12)$

单选题号 #10759

分值 2

下面代码实现了欧拉（线性）筛，横线处应填写（）。

vector euler_sieve(int n) {
 vector is_composite(n + 1, false); 
 vector 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;
}

$j \le n$

$j < sqrt(n)$

$j < primes.size()$

$j < i$

单选题号 #10760

分值 2

埃氏筛中将内层循环从 $j = i \times i$ 开始而不是 $j = 2 \times i$ 的主要原因是（）。

vector eratosthenes_sieve(int n) {
 vector is_composite(n + 1, false);
 vector 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;
}

因为 $2 \times i$ 一定不是合数

$i \times i$ 一定是质数

小于 $i \times i$ 的 $i$ 的倍数已被更小质因子筛过

这样可以把时间复杂度降为 $O(n )$

单选题号 #10761

分值 2

下面程序的运行结果为（）。

bool check(int n, int a[], int k, int dist) {
 int cnt = 1;
 int last = a[0];
 for (int i = 1; i = 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;
}

$2$

$3$

$4$

$5$

单选题号 #10762

分值 2

在升序数组中查找第一个大于等于 $x$ 的位置，下面循环中横线应填（）。

int lowerBound(const vector& a, int x){
 int l = 0, r = a.size(); 
 while(l = x) _____________;
 else l = mid + 1;
 }
 return l;
}

$r = mid;$

$r = mid-1;$

$l = mid;$

$l = mid + 1;$

单选题号 #10763

分值 2

关于递归函数调用，下列说法错误的是（）。

递归调用层次过深时，可能会耗尽栈空间导致栈溢出

尾递归函数可以通过编译器优化来避免栈溢出

所有递归函数都可以通过循环结构来改写，从而避免栈溢出

栈溢出发生时，程序会抛出异常并可以继续执行后续代码

单选题号 #10764

分值 2

给定 $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 = m) return true;
 }
 return false;
}
int main() {
 cin >> n >> m;
 long long mx = 0;
 for (int i = 1; i > 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;
}

l = mid + 1;
r = mid - 1;

l = mid - 1;
r = mid + 1;

l = mid + 1;
r = mid;

l = mid;
r = mid + 1;

🔒

已解锁前 10 题

第 11~27 题（共 17 题）需开通题库会员或使用积分包作答

本卷为 VIP 试卷：需开通题库会员（无限刷）或购买积分包（每题 1 积分）；已购长期正课学员自动享有权益