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

GESP C++ 5级 2025.03

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

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

单选题号 #11619

分值 2

链表不具备的特点是（）。

可随机访问任何一个元素

插入、删除操作不需要移动元素

无需事先估计存储空间大小

所需存储空间与存储元素个数成正比。

单选题号 #11620

分值 2

双向链表中每个结点有两个指针域 prev 和 next，分别指向该结点的前驱及后继结点。设 p 指向链表中的一个结点，它的前驱结点和后继结点非空。要删除结点 p，则下述语句中错误的是（）。

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

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

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

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

单选题号 #11621

分值 2

假设双向循环链表包含头尾哨兵结点（不存储实际内容），分别为 head 和 tail，链表中每个结点有两个指针域 prev 和 next，分别指向该结点的前驱及后继结点。下面代码实现了一个空的双向循环链表，横线上应填的最佳代码是（）。

// 链表结点
template 
struct ListNode {
 T data;
 ListNode* prev;
 ListNode* next;

 // 构造函数
 explicit ListNode(const T& val = T())
 : data(val), prev(nullptr), next(nullptr) {}
};

struct LinkedList {
 ListNode* head;
 ListNode* tail;
};

void InitLinkedList(LinkedList* list) {
 list->head = new ListNode;
 list->tail = new ListNode;
 ________________________________ // 在此处填入代码
};

list->head->prev = list->head;
list->tail->prev = list->head;

list->head->next = list->tail;
list->tail->prev = list->head;

list->head->next = list->tail;
list->tail->next = list->head;

list->head->next = list->tail;
list->tail->next = nullptr;

单选题号 #11622

分值 2

用以下辗转相除法（欧几里得算法）求 $\text{gcd}(84, 60)$ 的步骤中，第二步计算的数是（）。

int gcd(int a, int b) {
 int big = a > b ? a : b;
 int small = a < b ? a : b;
 if (big % small == 0) {
 return small;
 }
 return gcd(small, big % small);
}

$84$ 和 $60$

$60$ 和 $24$

$24$ 和 $12$

$12$ 和 $0$

单选题号 #11623

分值 2

根据唯一分解定理，下面整数的唯一分解是正确的（）。

$18 = 3\times6$

$28 = 4\times7$

$36 = 2\times3\times6$

$30 = 2\times3\times5$

单选题号 #11624

分值 2

下述代码实现素数表的线性筛法，筛选出所有小于等于 $n$ 的素数，横线上应填的最佳代码是（）。

vector sieve_linear(int n) {
 vector is_prime(n +1, true);
 vector primes;

 if (n < 2) return primes;

 is_prime[0] = is_prime[1] = false;
 for (int i = 2; i <= n/2; i++) {
 if (is_prime[i])
 primes.push_back(i);

 for (int j = 0; ____________________ ; j++) { // 在此处填入代码
 is_prime[ i * primes[j] ] = false;
 if (i % primes[j] == 0)
 break;
 }
 }

 for (int i = n/2 +1; i <= n; i++) {
 if (is_prime[i])
 primes.push_back(i);
 }

 return primes;
}

j < primes.size()

i * primes[j] <= n

j < primes.size() && i * primes[j] <= n

j <= n

单选题号 #11625

分值 2

在程序运行过程中，如果递归调用的层数过多，会因为（）引发错误。

系统分配的栈空间溢出

系统分配的堆空间溢出

系统分配的队列空间溢出

系统分配的链表空间溢出

单选题号 #11626

分值 2

对下面两个函数，说法错误的是（）。

int factorialA(int n) {
 if (n <= 1) return 1;
 return n * factorialA(n-1);
}
int factorialB(int n) {
 if (n <= 1) return 1;
 int res = 1;
 for(int i=2; i<=n; i++)
 res *= n;
}

两个函数的实现的功能相同。

两个函数的时间复杂度均为 $O(n)$ 。

factorialA 采用递归方式。

factorialB 采用递归方式。

单选题号 #11627

分值 2

下算法中，（）是不稳定的排序。

选择排序

插入排序

归并排序

冒泡排序

单选题号 #11628

分值 2

考虑以下 C++ 代码实现的快速排序算法，将数据从小到大排序，则横线上应填的最佳代码是（）。

int partition(vector& arr, int low, int high) {
 int pivot = arr[high]; // 基准值
 int i = low - 1;

 for (int j = low; j & arr, int low, int high) {
 if (low < high) {
 int pi = partition(arr, low, high);
 quickSort(arr, low, pi - 1);
 quickSort(arr, pi + 1, high);
 }
}

if (arr[j] > pivot) {
 i++;
 swap(arr[i], arr[j]);
}

if (arr[j] < pivot) {
 i++;
 swap(arr[i], arr[j]);
}

if (arr[j] < pivot) {
 swap(arr[i], arr[j]);
 i++;
}

if (arr[j] == pivot) {
 i++;
 swap(arr[i], arr[j]);
}

🔒

已解锁前 10 题

第 11~27 题（共 17 题）可在考试中作答

本卷为普通试卷：注册用户每题扣 1 积分（每日登录送 30 体验积分），交卷后查看答案与解析