首页 › 题库 › GESP编程能力等级认证 › 综合练习

GESP-C++五级 题库

共 67 道题 ,第 1 / 4 页 · 按题型筛选,点「查看答案」核对解析
1 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

区块链技术是比特币的基础。在区块链中,每个区块指向前一个区块,构成链式列表,新区块只能接在链尾,不允许在中间插入或删除。下面代码实现插入区块添加函数,则横线处填写( )。

//区块(节点) 
struct Block { 
    int index; // 区块编号(高度) 
    string data; // 区块里保存的数据 
    Block* prev; // 指向前一个区块 
    Block(int idx, const string& d, Block* p) : index(idx), data(d), prev(p) {} 
}; 
// 区块链 
struct Blockchain { 
    Block* tail; 
    // 初始化 
    void init() { 
        tail = new Block(0, "Genesis Block", nullptr); 
    } 
    // 插入新区块 
    void addBlock(const string& data) { 
        _______________________ //在此处填入代码 
    } 
    // 释放内存 
    void clear() { 
        Block* cur = tail; 
        while (cur != nullptr) { 
            Block* p = cur->prev; 
            delete cur; 
            cur = p; 
        } 
        tail = nullptr; 
    } 
};
A
Block* newBlock = new Block(tail->index + 1, data, tail);
tail = newBlock->prev;
B
Block* newBlock = new Block(tail->index + 1, data, tail);
tail = newBlock;
C
Block* newBlock = new Block(tail->index + 1, data, tail->prev);
tail = newBlock;
D
Block* newBlock = new Block(tail->index + 1, data, tail->prev);
tail = newBlock->prev;
答案与解析
正确答案:B
确定链尾当前区块,获取其编号与指针;创建新区块,编号为原尾部编号加一,数据为输入内容,前驱指针指向原尾部区块;更新区块链的尾指针,使其指向新创建的区块;确保链式结构连续,且新区块成为新的末端节点。
题目详情
2 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

下面代码尝试在有序数组中查找第一个大于等于 x 的元素位置。如果没有大于等于 x 的元素,返回arr.size() 。以下说法正确的是( )。

int lower_bound(vector<int>& arr, int x) { 
    int l = 0, r = arr.size(); 
    while(l < r) { 
        int mid = l + (r - l) / 2; 
        if(arr[mid] >= x) r = mid; 
        else l = mid + 1; 
    } 
    return l; 
}
A
上述代码逻辑正确
B
上述代码逻辑错误, while 循环条件应该用 l <= r
C
上述代码逻辑错误, mid 计算错误
D
上述代码逻辑错误,边界条件不对
答案与解析
正确答案:A
使用双指针维护搜索区间[l, r),循环条件为l < r。每次取中点mid = l + (r - l) / 2,避免整数溢出。若arr[mid] >= x,则第一个满足条件的位置在左半部分(含mid),更新r = mid;否则在右半部分,更新l = mid + 1。循环结束时l等于r,返回l。初始r设为数组长度可覆盖无解情况。
题目详情
3 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

下面给出了阶乘计算的两种方式。以下说法正确的是( )。

int factorial1(int n) { 
    if (n <= 1) return 1; 
    return n * factorial1(n - 1); 
} 
int factorial2(int n) { 
    int acc = 1; 
    while (n > 1) { 
        acc = n * acc; 
        n = n - 1; 
    } 
    return acc; 
}
A
上面两种实现方式的时间复杂度相同,都为O(n)
B
上面两种实现方式的空间复杂度相同,都为O(n)
C
上面两种实现方式的空间复杂度相同,都为O(1)
D
函数 factorial1() 的时间复杂度为O(2^n),函数 factorial2() 的时间复杂度为O(n)
答案与解析
正确答案:A
分析两个函数的执行机制。factorial1为递归实现,每次调用将当前n与factorial1(n-1)的结果相乘,递归深度随n线性增长,每层调用占用栈空间。factorial2为迭代实现,使用循环变量acc累积乘积,n递减至1时结束循环,仅使用固定数量的局部变量。时间复杂度由基本操作次数决定,两者均执行约n次乘法操作。空间复杂度由额外内存使用量决定,递归调用产生n层栈帧,迭代过程仅使用常数空间。
题目详情
4 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

下列关于排序的说法,正确的是( )。2025.12-5

A
快速排序是稳定排序
B
归并排序通常是稳定的
C
插入排序是不稳定排序
D
冒泡排序不是原地排序
答案与解析
正确答案:B
分析排序算法的稳定性时,需考察相等元素在排序前后相对位置是否保持不变。快速排序通过基准划分元素,交换过程可能导致相等元素顺序改变。归并排序在合并有序子序列时,若遵守左子序列优先原则,则相等元素的相对位置得以保留。插入排序将元素逐个插入已排序部分,若插入位置选择包含等于比较元素的情况,则可维持相对顺序。冒泡排序通过相邻元素交换实现,每轮将最小(或最大)元素移动到边界位置,仅使用常量级额外空间完成排序操作。原地排序指辅助空间复杂度为O(1)。
题目详情
5 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

函数 isPerfectNumber 判断一个正整数是否为完全数(该数是否即等于它的真因子之和),则横线上应填写( )。一个正整数 n 的真因子包括所有小于 n 的正因子,如28的真因子为1, 2, 4, 7, 14。

A

i <= n

B

i*i <= n

C

i <= n/2

D

i < n

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
6 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

函数 sieve 实现埃拉托斯特尼筛法(埃氏筛),横线处应填入( )。

A

i

B

i+1

C

i+2

D

i*i

答案与解析
正确答案:D
这道题暂未补解析。
题目详情
7 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

函数 linearSieve 实现线性筛法(欧拉筛),横线处应填入( )

A

i % p == 0

B

p % i == 0

C

i == p

D

i * p == n

答案与解析
正确答案:A
这道题暂未补解析。
题目详情
8 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

关于 埃氏筛 和 线性筛 的比较,下列说法错误的是( )

A

埃氏筛可能会对同一个合数进行多次标记

B

线性筛的理论时间复杂度更优,所以线性筛的速度往往优于埃氏筛

C

线性筛保证每个合数只被其最小质因子筛到一次

D

对于常见范围( n=<10^7),埃氏筛因实现简单,常数较小,其速度往往优于线性筛

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
9 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

给定一个 n x n 的矩阵 matrix ,矩阵的每一行和每一列都按升序排列。函数 countLE 返回矩阵中第k 小的元素,则两处横线上应分别填写( )。

A

hi = mid - 1;

lo = mid + 1;

B

hi = mid;

lo = mid;

C

hi = mid;

lo = mid + 1;

D

hi = mid + 1;

lo = mid;

答案与解析
正确答案:C
这道题暂未补解析。
题目详情
10 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

假设你是一家电影院的排片经理,只有一个放映厅。你有一个电影列表 movies ,其中 movies[i] = [start_i, end_i] 表示第 i 部电影的开始和结束时间。请你找出最多能安排多少部不重叠的电影,则横线上应分别填写的代码为( )。

A

a[0] < b[0] 和 lastEnd

B

a[1] < b[1] 和 lastEnd

C

a[0] < b[0] 和 movies[i][0]

D

a[1] < b[1] 和 movies[i][0]

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
11 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

给定一个整数数组 nums ,下面代码找到一个具有最大和的连续子数组,并返回该最大和。则下面说法错误的是( )。

A

上述代码采用分治算法实现

B

上述代码采用贪心算法

C

上述代码时间复杂度为O(n log n)

D

上述代码采用递归方式实现

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
12 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

给定一个由非负整数组成的数组 digits ,表示一个非负整数的各位数字,其中最高位在数组首位,且digits 不含前导0(除非是0本身)。下面代码对该整数执行 +1 操作,并返回结果数组,则横线上应填写( )

A

digits[i] = 0;

B

digits[i] = 9;

C

digits[i] = 1;

D

digits[i] = 10;

答案与解析
正确答案:A
这道题暂未补解析。
题目详情
13 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

下面的C++代码,用于求一系列数据中的最大值。有关其算法说法【错误】的是?( )

int find_max_recursive(const vector<int>& nums, int left, int right) {
    if (left == right)
        return nums[left];
    int mid = left + (right - left) / 2;
    int left_max = find_max_recursive(nums, left, mid);
    int right_max = find_max_recursive(nums, mid + 1, right);
    return max(left_max, right_max);
}
int find_max(const vector<int>& nums) {
    if (nums.empty()) {
        throw invalid_argument("输入数组不能为空");
    }
    return find_max_recursive(nums, 0, nums.size() - 1);
}
A
该算法采用分治算法
B
该算法是递归实现
C
该算法采用贪心算法
D
该算法不是递推算法
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
14 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

下面的C++代码,用于求一系列数据中的最大值。有关其算法说法【错误】的是?( )

int find_max(const vector<int>& nums) {
    if (nums.empty()) {
        throw invalid_argument("输入数组不能为空");
    }
    int max_value = nums[0];
    for (int num : nums) {
        if (num > max_value) {
            max_value = num;
        }
    }
    return max_value;
}
A
本题 find_max() 函数采用的是迭代算法
B
本题 find_max() 函数的时间复杂度为 O(n)
C
和上一题的 find_max() 相比,因为没有递归,所以没有栈的创建和销毁开销
D
本题 find_max() 函数和上一题的 find_max() 时间复杂度相同
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
15 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

下面的 C++ 代码用于在升序数组 lst 中查找目标值 target 最后一次出现的位置。相关说法,正确的是?( )

int binary_search_last_occurrence(const vector<int>& lst, int target) {
    if (lst.empty()) return -1;
    int low = 0, high = lst.size() - 1;
    while (low < high) {
        int mid = (low + high + 1) / 2;
        if (lst[mid] <= target) {
            low = mid;
        } else {
            high = mid - 1;
        }
    }
    if (lst[low] == target)
        return low;
    else
        return -1;
}
A
当 lst 中存在重复的 target 时,该函数总能返回最后一个 target 的位置,即便 lst 全由相同元素组成
B
当 target 小于 lst 中所有元素时,该函数会返回 0
C
循环条件改为 while (low <= high) 程序执行效果相同,且能提高准确性
D
将代码中 (low + high + 1) / 2 修改为 (low + high) / 2 效果相同
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
16 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

硬币找零问题中要求找给客户最少的硬币。 coins 存储可用硬币规格,单位为角,假设规格都小于10角,且一定有1角规格。 

amount 为要找零的金额,约定必须为1角的整数倍。输出为每种规格及其数量,按规格从大到小输出,如果某种规格不必要,则输出为0。

下面是其实现代码,相关说法正确的是?( )

const int MAX_COINS = 10;
int result[MAX_COINS] = {0}; // 假设最多10种面额
int find_coins(const vector<int>& coins, int amount) {
    sort(coins.begin(), coins.end(), greater<int>());
    int n = coins.size();
    for (int i = 0; i < n; ++i) {
        int coin = coins[i];
        int num = amount / coin;
        result[i] = num;
        amount -= num * coin;
        if (amount == 0) break;
    }
    cout << "找零方案如下:" << endl;
    for (int i = 0; i < n; ++i) {
        cout << sorted_coins[i] << "角需要" << result[i] << "枚" << endl;
    }
    return 0;
}
A
上述代码采用贪心算法实现
B
针对本题具体要求,上述代码总能找到最优解
C
上述代码采用枚举算法
D
上述代码采用分治算法
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
17 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

对下面两个函数,说法【错误】的是?( )

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 *= i;
}
A
两个函数的实现的功能相同。
B
两个函数的时间复杂度均为 O(n)。
C
factorialA采用递归方式。
D
factorialB采用递归方式。
答案与解析
正确答案:D

两个计算阶乘的函数 factorialA 和 factorialB。

factorialA采用递归的方法,factorialB 采用循环方式实现,二者的时间复杂度均为O(n)。

题目详情
18 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

下算法中,( )是不稳定的排序?

A
选择排序
B
插入排序
C
归并排序
D
冒泡排序
答案与解析
正确答案:A

稳定排序 是指:如果两个相等的元素在排序前后的相对位置保持不变。

不稳定排序 是指:相等的元素在排序后可能交换位置。

对于选择排序,每次从未排序部分选择最小(或最大)元素,放到已排序部分的末尾。

例如:[5, 5, 2]进行排序,[5(1), 5(2), 2](用下标区分两个 5),找到最小值 2,交换 5(1)和 2,数组变为:[2, 5(2), 5(1)],两个5的相对顺序改变了。

题目详情
19 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

若用二分法在[1, 100]内猜数,最多需要猜( )次?

A
100
B
10
C
7
D
5
答案与解析
正确答案:C

二分查找每次将搜索区间对半分,最坏情况下需要猜测的次数:

2^6<100(6 次不够),2^7>=100(7 次足够)。

题目详情
20 单选题 适中 GESP编程能力等级认证 ·GESP-C++五级 · 综合练习

函数 int findMax(int arr[], int low, int high) 计算数组中最大元素,其中数组 arr 从索引low 到 high ,( )正确实现了分治逻辑?

A
if (low == high)
    return arr[low];
int mid = (low + high) / 2;
return arr[mid];
B
if (low >= high)
    return arr[low];
int mid = (low + high) / 2;
int leftMax = findMax(arr, low, mid - 1);
int rightMax = findMax(arr, mid, high);
return leftMax + rightMax;
C
if (low > high)
    return 0;
int mid = low + (high - low) / 2;
int leftMax = findMax(arr, low, mid);
int rightMax = findMax(arr, mid + 1, high);
return leftMax * rightMax;
D
if (low == high)
    return arr[low];
int mid = low + (high - low) / 2;
int leftMax = findMax(arr, low, mid);
int rightMax = findMax(arr, mid + 1, high);
return (leftMax > rightMax) ? leftMax : rightMax;
答案与解析
正确答案:D

分治法的核心思想是:分解,解决,合并。

对于 求数组最大值,分治法的具体实现是:

基准情况:如果 low == high,说明区间只有一个元素,直接返回 arr[low]。

分解:计算中间位置 mid。

递归求左半部分 [low, mid] 的最大值 leftMax。

递归求右半部分 [mid+1, high] 的最大值 rightMax。

合并:比较 leftMax 和 rightMax,返回较大者。

题目详情