CCF编程能力等级认证GESP—C++6级—20250628

最新推荐文章于 2025-12-31 19:32:08 发布

原创最新推荐文章于 2025-12-31 19:32:08 发布 · 2.5k 阅读

55 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #开发语言

CCF编程能力等级认证(GESP)真题解析同时被 2 个专栏收录

84 篇文章

订阅专栏

C++ - 6级

10 篇文章

订阅专栏

CCF编程能力等级认证GESP—C++6级—20250628

单选题（每题 2 分，共 30 分）
判断题（每题 2 分，共 20 分）
编程题 (每题 25 分，共 50 分)
- 学习小组
- 最大因数

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

1、下列哪一项不是面向对象编程的基本特征？

A. 继承
B. 封装
C. 多态
D. 链接

正确答案：D

2、为了让 Dog 类的构造函数能正确地调用其父类 Animal 的构造方法，横线线处应填入（）

class Animal {
public:
	std::string name;
	Animal(std::string str) : name(str) {
		std::cout << "Animal created\n";
	}
	virtual void speak() {
		cout << "Animal speaks" << endl;
	}
};
class Dog : public Animal {
	std::string breed;
public:
	Dog(std::string name, std::string b) : _________________, breed(b) {
		std::cout << "Dog created\n";
	}
	void speak() override {
		cout << "Dog barks" << endl;
	}
};
int main() {
	Animal* p = new Dog("Rex", "Labrador");
	p->speak();
	delete p;
	return 0;
}

A. Animal(name)
B. super(name)
C. Animal::Animal(name)
D. Animal()

正确答案：A

3、代码同上一题，代码执行结果是（）。

A. 输出 Animal speaks
B. 输出 Dog barks
C. 编译错误
D. 程序崩溃

正确答案：B

4、以下关于栈和队列的代码，执行后输出是（）。

stack<int> s;
queue<int> q;
for (int i = 1; i <= 3; ++i) {
	s.push(i);
	q.push(i);
}
cout << s.top() << " " << q.front() << endl;

A. 1 3
B. 3 1
C. 3 3
D. 1 1

正确答案：B

5、在一个循环队列中， front 是指向队头的指针， rear 指向队尾的指针，队列最大容量为 maxSize 。判断队列已满的条件是（）。

A. rear == front
B. (rear + 1) % maxSize == front
C. (rear - 1 + maxSize) % maxSize == front
D. (rear - 1) == front

正确答案：B

6、（）只有最底层的节点未被填满，且最底层节点尽量靠左填充。

A. 完美二叉树
B. 完全二叉树
C. 完满二叉树
D. 平衡二叉树

正确答案：B

7、在使用数组表示完全二叉树时，如果一个节点的索引为（从开始计数），那么其左子节点的索引通常是（）。

A. (i - 1) / 2
B. i + 1
C. i * 2
D. 2 * i + 1

正确答案：D

8、已知一棵二叉树的前序遍历序列为 GDAFEMHZ ，中序遍历序列为 ADFGEHMZ ，则其后序遍历序列为（）。

A. ADFGEHMZ
B. ADFGHMEZ
C. AFDGEMZH
D. AFDHZMEG

正确答案：D

9、设有字符集 {a, b, c, d, e}，其出现频率分别为 {5, 8, 12, 15, 20}，得到的哈夫曼编码为（）。

A.
a:010
b:011
c:00
d:10
e:11

B.
a:00
b:10
c:011
d:100
e:111

C.
a:10
b:01
c:011
d:100
e:111

D.
a:100
b:01
c:011
d:100
e:00

正确答案：A

10、 3位格雷编码中，编码 101 之后的下一个编码不可能是（）。

A. 100
B. 111
C. 110
D. 001

正确答案：C

11、请将下列 C++ 实现的深度优先搜索（DFS）代码补充完整，横线处应填入（）。

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
void dfs(TreeNode* root, vector<int>& result) {
	if (root == nullptr) return;
	__________________________
}

A.
result.push_back(root->val);
dfs(root->left);
dfs(root->right);

B.
result.push_back(root->left->val);
dfs(root->right);
dfs(root->left);

C.
result.push_back(root->left->val);
dfs(root->left);
dfs(root->right);

D.
result.push_back(root->right->val);
dfs(root->right);
dfs(root->left);

正确答案：A

12、给定一个二叉树，返回每一层中最大的节点值，结果以数组形式返回，横线处应填入（）。

#include <vector>
#include <queue>
#include <algorithm>
struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
vector<int> largestValues(TreeNode* root) {
	vector<int> result;
	if (!root) return result;
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty()) {
		int sz = q.size();
		int maxVal = INT_MIN;
		for (int i = 0; i < sz; ++i) {
			TreeNode* node;
			_______________________________
			maxVal = max(maxVal, node->val);
			if (node->left) q.push(node->left);
			if (node->right) q.push(node->right);
		}
		result.push_back(maxVal);
	}
	return result;
}

A.node = q.end();
B.node = q.front();
C.q.pop(); node = q.front();
D.node = q.front();q.pop();

正确答案：D

13、下面代码实现一个二叉排序树的插入函数（没有相同的数值），横线处应填入（）。

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};
void insert(TreeNode*& root, int key) {
	if (!root) {
		root = new TreeNode(key);
		return;
	}
	_______________________________
}

A.
if (key < root->val)
	insert(root->left, key);
else if (key > root->val)
	insert(root->right, key);

B.
if (key < root->val)
	insert(root->right, key);
else if (key > root->val)
	insert(root->left, key);

C.
insert(root->left, key);
insert(root->right, key);

D.
insert(root->right, key);
insert(root->left, key);

正确答案：A

14、以下关于动态规划算法特性的描述，正确的是（）。

A. 子问题相互独立，不重叠
B. 问题包含重叠子问题和最优子结构
C. 只能从底至顶迭代求解
D. 必须使用递归实现，不能使用迭代

正确答案：B

15、给定n个物品和一个最大承重为w的背包，每个物品有一个重量wt[i]和价值val[i]，每个物品只能选择放或不放。目标是选择若干个物品放入背包，使得总价值最大，且总重量不超过w。关于下面代码，说法正确的是（）。

int knapsack1D(int W, vector<int>& wt, vector<int>& val, int n) {
	vector<int> dp(W+1, 0);
	for (int i = 0; i < n; ++i) {
		for (int w = W; w >= wt[i]; --w) {
			dp[w] = max(dp[w], dp[w - wt[i]] + val[i]);
		}
	}
	return dp[W];
}

A. 该算法不能处理背包容量为 0 的情况
B. 外层循环 i 遍历背包容量，内层遍历物品
C. 从大到小遍历 w 是为了避免重复使用同一物品
D. 这段代码计算的是最小重量而非最大价值

正确答案：C

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

1、构造函数可以被声明为 virtual。

正确答案：错误

2、给定一组字符及其出现的频率，构造出的哈夫曼树是唯一的。

正确答案：错误

3、为了实现一个队列，使其出队操作（ pop ）的时间复杂度为O(1)并且避免数组删除首元素的O(n)问题，一种常见且有效的方法是使用环形数组，通过调整队首和队尾指针来实现。

正确答案：正确

4、对一棵二叉排序树进行中序遍历，可以得到一个递增的有序序列。

正确答案：正确

5、如果二叉搜索树在连续的插入和删除操作后，所有节点都偏向一侧，导致其退化为类似于链表的结构，这时其查找、插入、删除操作的时间复杂度会从理想情况下的O(logn)退化到O(nlogn)。

正确答案：错误

6、执行下列代码， my_dog.name 的最终值是 Charlie 。

class Dog {
public:
	std::string name;
	Dog(std::string str) : name(str) {}
};
int main() {
	Dog my_dog("Buddy");
	my_dog.name = "Charlie";
	return 0;
}

正确答案：正确

7、下列 C++ 代码可以成功编译，并且子类 Child 的实例能通过其成员函数访问父类 Parent 的属性value 。

class Parent {
private:
	int value = 100;
};
class Child : public Parent {
public:
	int get_private_val() {
		return value; // 尝试访问父类的私有成员
	}
};

正确答案：错误

8、下列代码中的 tree 向量，表示的是一棵完全二叉树 ( -1 代表空节点)按照层序遍历的结果。

#include <vector>
std::vector<int> tree = {1, 2, 3, 4, -1, 6, 7};

正确答案：错误

9、在树的深度优先搜索（DFS）中，使用栈作为辅助数据结构以实现“先进后出”的访问顺序。

正确答案：正确

10、下面代码采用动态规划求解零钱兑换问题：给定n种硬币，第 𝑖 种硬币的面值为𝑐𝑜𝑖𝑛𝑠[𝑖 − 1] ，目标金额为𝑎𝑚𝑡 ，每种硬币可以重复选取，求能够凑出目标金额的最少硬币数量；如果不能凑出目标金额，返回 -1 。

int coinChangeDPComp(vector<int> &coins, int amt) {
	int n = coins.size();
	int MAX = amt + 1;
	vector<int> dp(amt + 1, MAX);
	dp[0] = 0;
	for (int i = 1; i <= n; i++) {
		for (int a = 1; a <= amt; a++) {
			if (coins[i - 1] > a)
				dp[a] = dp[a];
			else
				dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
		}
	}
	return dp[amt] != MAX ? dp[amt] : -1;
}

正确答案：正确

编程题 (每题 25 分，共 50 分)

学习小组

【问题描述】
班主任计划将班级里的n名同学划分为若干个学习小组，每名同学都需要分入某一个学习小组中。观察发现，如果一个学习小组中恰好包含k名同学，则该学习小组的讨论积极度为 $a_k$ 。
给定讨论积极度 $a_1,a_2,…,a_n$ ,请你计算将这n名同学划分为学习小组的所有可能方案中，讨论积极度之和的最大值。

【输入格式】
第一行，一个正整数n,表示班级人数。

第二行，n个非负整数 $a_1,a_2,…,a_n$ ,表示不同人数学习小组的讨论积极度。

【输出格式】
输出共一行，一个整数，表示所有划分方案中，学习小组讨论积极度之和的最大值。
【样例输入 1】
4
1 5 6 3
【样例输出 1】
10
【样例输入 2】
8
0 2 5 6 4 3 3 4
【样例输出 2】
12
【数据范围】
对于40%的测试点，保证 $1 \leq n \leq 10$ 。
对于所有测试点，保证 $1≤n≤1000,0≤a_i≤10^4$ 。

最大因数

【问题描述】
给定一棵有 $10^9$ 个结点的有根树，这些结点依次以 $1,2,.,10^9$ 编号，根结点的编号为1。对于编号为 $k(2≤k≤10^9)$ 的结点，其父结点的编号为k的因数中除k以外最大的因数。
现在有q组询问，第 $i (1 \leq i \leq q)$ 组询问给定 $x_i,y_i$ ,请你求出编号分别为 $x_i,y_i$ 的两个结点在这棵树上的距离。两个结点之间的距离是连接这两个结点的简单路径所包含的边数。

【输入格式】
第一行，一个正整数q,表示询问组数。

接下来q行，每行两个正整数 $x_i,y_i$ ,表示询问结点的编号。

【输出格式】
输出共q行，每行一个整数，表示结点 $x_i,y_i$ 之间的距离。

【样例输入 1】
3
1 3
2 5
4 8
【样例输出 1】
1
2
1
【样例输入 2】
1
120 650
【样例输出 2】
9
【数据范围】
对于60%的测试点，保证 $1≤x_i,y_i≤1000$ 。
对于所有测试点，保证 $1≤q≤1000,1≤x_i,y_i≤10^9$ 。