当前位置： 首页 > news >正文

GESP认证C++编程真题解析 | 202512 六级

news 2026/5/11 15:32:18

​欢迎大家订阅我的专栏：算法题解：C++与Python实现！
本专栏旨在帮助大家从基础到进阶 ，逐步提升编程能力，助力信息学竞赛备战！

专栏特色
1.经典算法练习：根据信息学竞赛大纲，精心挑选经典算法题目，提供清晰的代码实现与详细指导，帮助您夯实算法基础。
2.系统化学习路径：按照算法类别和难度分级，从基础到进阶，循序渐进，帮助您全面提升编程能力与算法思维。

适合人群：

  • 准备参加蓝桥杯、GESP、CSP-J、CSP-S等信息学竞赛的学生
  • 希望系统学习C++/Python编程的初学者
  • 想要提升算法与编程能力的编程爱好者

附上汇总帖：GESP认证C++编程真题解析 | 汇总

单选题

第1题

在面向对象编程中，下列关于 虚函数 的描述中，错误的是（ ）。

A. 虚函数用于支持运行时多态

B. 通过基类指针调用虚函数时，会根据对象实际类型决定调用版本

C. 构造函数可以声明为虚函数以支持多态

D. 基类析构函数常声明为虚函数以避免资源泄漏

【答案】：C

【解析】

虚函数的核心作用是实现运行时多态（动态绑定），即根据实际对象类型调用对应函数，A正确。

如果在基类中已经实现了虚函数，派生类中可以不重写，B正确。

构造函数不能是虚函数，C错误。

基类的析构函数最好是虚函数，否则通过基类指针删除派生类对象时可能会导致资源泄露，D正确。

第2题

执行如下代码，会输出 钢琴：叮咚叮咚 和 吉他：咚咚当当 。这体现了面向对象编程的（ ）特性。

class Instrument {
public:virtual void play() {cout << "乐器在演奏声音" << endl;
}virtual ~Instrument() {}
};class Piano : public Instrument {
public:void play() override {cout << "钢琴：叮咚叮咚" << endl;}
};class Guitar : public Instrument {
public:void play() override {cout << "吉他：咚咚当当" << endl;}
};int main() {Instrument* instruments[2];instruments[0] = new Piano();instruments[1] = new Guitar();for (int i = 0; i < 2; ++i) {instruments[i]->play();}for (int i = 0; i < 2; ++i) {delete instruments[i];}return 0;
}

A. 继承

B. 封装

C. 多态

D. 链接

【答案】：C

【解析】

封装是把数据和操作数据的方法打包在一起，并隐藏内部细节。
继承是一个类可以获取另一个类的属性和方法，实现代码复用。
多态是指同一个方法在不同对象中有不同的实现，调用时会根据对象类型自动选择对应的行为。
通过基类指针调用虚函数，会根据实际对象类型执行不同派生类的实现，C正确。

第3题

关于以下代码，说法正确的是（ ）。

class Instrument {
public:void play() {cout << "乐器在演奏声音" << endl;}virtual ~Instrument() {}
};class Piano : public Instrument {
public:void play() override {cout << "钢琴：叮咚叮咚" << endl;}
};class Guitar : public Instrument {
public:void play() override {cout << "吉他：咚咚当当" << endl;}
};int main() {Instrument* instruments[2];instruments[0] = new Piano();instruments[1] = new Guitar();for (int i = 0; i < 2; ++i) {instruments[i]->play();}for (int i = 0; i < 2; ++i) {delete instruments[i];}return 0;
}

A. 执行代码会输出两行，内容分别为： 钢琴：叮咚叮咚 和 吉他：咚咚当当

B. 执行代码会输出两行，内容分别为： 乐器在演奏声音 和 乐器在演奏声音

C. 代码编译出现错误

D. 代码运行出现错误

【答案】：C

【解析】

编译错误的原因是play在基类Instrument中不是虚函数，继承之后是无法实现多态的。
Piano和Guitar里的play方法标记为override。override关键字要求基类中对应的函数必须是虚函数。Instrument类中play函数不是虚函数，所以会编译出错。

第4题

某文本编辑器把用户输入的字符依次压入栈 S。用户依次输入 A , B , C , D 后，用户按了两次撤销（每次撤销，弹出栈顶一个字符）。此时栈从栈底到栈顶的内容是：（ ）。

A. A B

B. A B C

C. A B D

D. B C

【答案】：A

【解析】

按照后进先出的结构，最终栈底到栈顶的内容是 A B。

第5题

假设循环队列数组长度为 N ，其中队空判断条件为： front == rear ，队满判断条件为： (rear + 1) % N == front ，出队对应的操作为： front = (front + 1) % N ，入队对于的操作为： rear = (rear + 1) % N 。循环队列长度 N = 6 ，初始 front = 1 , rear = 1 ，执行操作序列为：入队, 入队, 入队, 出队, 入队, 入队， 则最终 (front, rear) 的值是（ ）。

A. (2, 5)

B. (2, 0)

C. (3, 5)

D. (3, 0)

【答案】：B

【解析】

初始：N=6，front=1，rear=1
入队：rear = (1+1)%6 = 2
入队：rear = (2+1)%6 = 3
入队：rear = (3+1)%6 = 4
出队：front = (1+1)%6 = 2
入队：rear = (4+1)%6 = 5
入队：rear = (5+1)%6 = 0
最终：front=2，rear=0

第6题

以下函数 check() 用于判断一棵二叉树是否为（ ）。

bool check(TreeNode* root) {if (!root) return true;queue<TreeNode*> q;q.push(root);bool hasNull = false;while (!q.empty()) {TreeNode* cur = q.front(); q.pop();if (!cur) {hasNull = true;} else {if (hasNull) return false;q.push(cur->left);q.push(cur->right);}}return true;
}

A. 满二叉树

B. 完全二叉树

C. 二叉搜索树

D. 平衡二叉树

【答案】：B

【解析】

题目中使用队列进行BFS层次遍历。当遇到一个空节点时，会做一个标记；如果在此之后又遇到空结点，说明该树不是完全二叉树。因为在完全二叉树中，一旦出现空节点，其后不能再有非空结点。

第7题

以下代码实现了二叉树的（ ）。

void traverse(TreeNode* root) {if (!root) return;traverse(root->left);traverse(root->right);cout << root->val << " ";
}

A. 前序遍历

B. 中序遍历

C. 后序遍历

D. 层序遍历

【答案】：C

【解析】

递归处理左子树，递归处理右子树，最后输出根结点的信息，这种为后序遍历。

第8题

下面代码实现了哈夫曼编码，则横线处应填写的代码是（ ）。

struct Symbol {char ch; //字符long long freq; //频率string code; //哈夫曼编码
};struct Node {long long w; //权值int l, r; //左右孩子（节点下标），-1 表示空int sym; // 叶子对应符号下标；内部节点为 -1Node(long long _w=0, int _l=-1, int _r=-1, int _sym=-1): w(_w), l(_l), r(_r), sym(_sym) {}
};// 从 A(leafIdx) 和 B(internalIdx) 的队首取最小的一个节点下标
static int PopMinNode(const vector<Node>& nodes,const vector<int>& leafIdx, int n, int& pA,const vector<int>& internalIdx, int& pB) {if (pA < n && (pB >= (int)internalIdx.size() ||nodes[leafIdx[pA]].w <= nodes[internalIdx[pB]].w)) {return leafIdx[pA++];}else {return internalIdx[pB++];}
}// DFS 生成编码（左 0，右 1）
static void DFSBuildCodes(int u, const vector<Node>& nodes, Symbol sym[], string& path) {if (u == -1) return;if (nodes[u].sym != -1) { // 叶子sym[nodes[u].sym].code = path;return;}path.push_back('0');DFSBuildCodes(nodes[u].l, nodes, sym, path);path.pop_back();path.push_back('1');DFSBuildCodes(nodes[u].r, nodes, sym, path);path.pop_back();
}int BuildHuffmanCodes(Symbol sym[], int n) {for (int i = 0; i < n; i++) sym[i].code.clear();if (n <= 0) return -1;// 只有一个字符：约定编码为 "0"if (n == 1) {sym[0].code = "0";return 0;}vector<Node> nodes;nodes.reserve(2 * n);// 1) 建立叶子节点vector<int> leafIdx(n);for (int i = 0; i < n; i++) {leafIdx[i] = (int)nodes.size();nodes.push_back(Node(sym[i].freq, -1, -1, i));}// 2) 叶子按权值排序（A 队列）sort(leafIdx.begin(), leafIdx.end(),[&](int a, int b) {if (nodes[a].w != nodes[b].w) return nodes[a].w < nodes[b].w;return nodes[a].sym < nodes[b].sym; // 稳定一下});// B 队列（内部节点下标队列）vector<int> internalIdx;internalIdx.reserve(n);int pA = 0, pB = 0;// 3) 合并 n-1 次for (int k = 1; k < n; k++) {int x = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);int y = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);int z = (int)nodes.size();________________________ // 在此处填写代码}int root = internalIdx.back();// 4) DFS 生成编码string path;DFSBuildCodes(root, nodes, sym, path);return root;
}

A.

nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, -1));
internalIdx.push_back(z);

B.

nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, -1));
leafIdx.push_back(z);

C.

internalIdx.push_back(z);
nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, x+y));

D.

nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, x+y));
leafIdx.push_back(z);

【答案】：A

【解析】

-1表示内部结点，因为合并后形成的新节点一定是内部结点，而非叶子结点。
因为leaf表示叶子结点，internal表示内部结点。变量internalIdx用于存储新合并形成的结点的索引。

第9题

以下关于哈夫曼编码的说法，正确的是（ ）。

A. 哈夫曼编码是定长编码

B. 哈夫曼编码中，没有任何一个字符的编码是另一个字符编码的前缀

C. 哈夫曼编码一定唯一

D. 哈夫曼编码不能用于数据压缩

【答案】：B

【解析】

哈夫曼编码用于压缩，是一种不定长的前缀码，其编码结果不一定唯一。A、C、D错误。

第10题

以下函数实现了二叉排序树（BST）的（ ）操作。

TreeNode* op(TreeNode* root, int x) {if (!root) return new TreeNode(x);if (x < root->val)root->left = op(root->left, x);elseroot->right = op(root->right, x);return root;
}

A. 查找

B. 插入

C. 删除

D. 遍历

【答案】：B

【解析】

题目中的new操作表示新建一个结点。

第11题

下列代码实现了树的深度优先遍历，则横线处应填入（ ）。

struct TreeNode {int val;TreeNode* left;TreeNode* right;TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};void dfs(TreeNode* root) {if (!root) return;stack<TreeNode*> st;st.push(root);while (!st.empty()) {TreeNode* node = st.top(); st.pop();cout << node->val << " ";if (node->right) st.push(node->right);________________________}
}

A. if (node->left) st.push(node->left);

B. if (node->left) st.pop(node->left);

C. if (node->left) st.front(node->left);

D. if (node->left) st.push(node->right);

【答案】：A

【解析】

左子节点存在时，将左子结点入栈。选A。

第12题

给定一棵普通二叉树（节点值没有大小规律），下面代码判断是否存在值为 x 的结点，则横线处应填入（ ）。

struct TreeNode {int val;TreeNode* left;TreeNode* right;TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};TreeNode* bfsFind(TreeNode* root, int x) {if (!root) return nullptr;queue<TreeNode*> q;q.push(root);while (!q.empty()) {TreeNode* cur = q.front(); q.pop();if (cur->val == x) return cur;________________________}return nullptr;
}

A. q.push(cur);

B. if (cur->right) q.push(cur->right);

C.

if (cur->left)q.push(cur->left);
if (cur->right)q.push(cur->right);

D.

q.push(cur->left);
q.push(cur->right);

【答案】：C

【解析】

左子节点存在则将左子结点入队，右子节点存在则将右子节点入队。

第13题

在二叉排序树（Binary Search Tree, BST）中，假设节点值互不相同。给定如下搜索函数，以下说法一定正确的是（ ）。

bool find(Node* root, int x) {while (root) {if (root->val == x) return true;root = (x < root->val) ? root->left : root->right;}return false;
}

A. 最坏情况下，访问结点数是 \(O(logn)\)

B. 最坏情况下，访问结点数是 \(O(n)\)

C. 无论如何，访问结点数都不超过树高的一半

D. 一定比在普通二叉树中搜索快

【答案】：B

【解析】

二叉排序树最坏情况下访问次数是树的高度，即树退化成一条链。

第14题

0/1 背包（每件物品最多选一次）问题通常可用一维动态规划求解，核心代码如下。则下面说法正确的是（ ）。

for each item (w, v):for (int j = W; j >= w; --j)dp[j] = max(dp[j], dp[j-w] + v);

A. 内层 j 必须从小到大，否则会漏解

B. 内层 j 必须从大到小，否则同一件物品会被用多次

C. j 从大到小或从小到大都一样

D. 只要 dp 初始为 0 ，方向无所谓

【答案】：B

【解析】

降维时，维度应该从大到小，不然物品可能会被用多次。

第15题

以下关于动态规划的说法中，错误的是（ ）。

A. 动态规划方法通常能够列出递推公式。

B. 动态规划方法的时间复杂度通常为状态的个数。

C. 动态规划方法有递推和递归两种实现形式。

D. 对很多问题，递推实现和递归实现动态规划方法的时间复杂度相当。

【答案】：B

【解析】

动态规划的时间复杂度通常是状态个数乘以每个状态转移的代价，B错误。
递推和递归都可以实现动态规划，在实现良好的情况下，两种方式的时间复杂度相当。

判断题

第1题

以下代码中，构造函数被调用的次数是1次。

class Test {
public:Test() { cout << "T "; }
};int main() {Test a;Test b = a;
}

A. 正确

B. 错误

【答案】：B

【解析】

构造函数被调用两次：一次普通构造函数，一次拷贝构造函数。

第2题

面向对象编程中，封装是指将数据和操作数据的方法绑定在一起，并对外隐藏实现细节。

A. 正确

B. 错误

【答案】：A

【解析】

题目描述正确。

第3题

以下代码能够正确统计二叉树中叶子结点的数量。

int countLeaf(TreeNode* root) {if (!root) return 0;if (!root->left && !root->right) return 1;return countLeaf(root->left) + countLeaf(root->right);
}

A. 正确

B. 错误

【答案】：A

【解析】

叶子结点定义为没有子节点的结点。

第4题

广度优先遍历二叉树可用栈来实现。

A. 正确

B. 错误

【答案】：B

【解析】

广度优先遍历使用队列实现。

第5题

函数调用管理可用栈来管理。

A. 正确

B. 错误

【答案】：A

【解析】

函数调用遵循”后进先出“的顺序，正是通过栈结构来实现的。

第6题

在二叉排序树（BST）中，若某结点的左子树为空，则该结点一定是整棵树中的最小值结点。

A. 正确

B. 错误

【答案】：B

【解析】

不可能每个叶子结点都是整棵树的最小值，最小值一定位于最左边的路径上。

第7题

下面的函数能正确判断一棵树是不是二叉排序树（左边的数字要比当前数字小，右边的数字要比当前数字大）。

bool isBST(TreeNode* root, int minVal, int maxVal) {if (!root) return true;if (root->val <= minVal || root->val >= maxVal)return false;return isBST(root->left, minVal, root->val) &&isBST(root->right, root->val, maxVal);
}

A. 正确

B. 错误

【答案】：A

【解析】

代码核心思想是：每个结点的值必须在合法范围内，即大于等于最小值且小于等于最大值。

第8题

格雷编码相邻两个编码之间必须有多位不同，以避免数据传输错误。

A. 正确

B. 错误

【答案】：B

【解析】

格雷编码相邻两个编码之间仅有一位不同，以避免数据传输错误。

第9题

小杨在玩一个闯关游戏，从第 1 关走到第 4 关。每一关的体力消耗如下（下标表示关卡编号）： cost = [ 0, 3, 5, 2, 4 ] ，其中 cost[i] 表示到达第 i 关需要消耗的体力， cost[0]=0 表示在开始状态，体力消耗为 0。小杨每次可以从当前关卡 前进 1 步或 2 步。按照上述规则，从第 1 关到第 4 关所需消耗的最小体力为 7。

A. 正确

B. 错误

【答案】：B

【解析】

f[i] = min(f[i-1], f[i-2]) + cost[i]，依次计算：
f[2] = min(f[1], 0) + cost[2] = 5
f[3] = min(f[2], f[1]) + cost[3] = 5
f[4] = min(f[3], f[2]) + cost[4] = 9
因此最小体力为9，不是7。

第10题

假定只有一个根节点的树的深度为1，则一棵有 \(n\) 个节点的完全二叉树，则树的深度为 \(\lfloor log_2(n)\rfloor +1\)。

A. 正确

B. 错误

【答案】：A

【解析】

完全二叉树深度为 \(h\) 时，结点数 \(n\) 满足：\(2^{h-1}\le n\le 2^h-1\)。对不等式取 \(log_2\) 得：\(h - 1\le log_2(n)\lt h\)，所以 \(h = \lfloor log_2(n)\rfloor +1\)。

编程题

题解：洛谷 P14919 [GESP202512 六级] 路径覆盖

题解：洛谷 P14920 [GESP202512 六级] 道具商店

http://www.jsqmd.com/news/796579/

相关文章：

  • 玻璃钢生物除臭箱技术选型与主流厂商实测对比 - 奔跑123
  • 从仿真到实践：三相SPWM并网逆变器的电流环PI参数整定心得（附PSIM波形分析）
  • Python自动化办公新思路：5分钟教你用Pywinauto+Lackey批量操作电脑软件（以Tim自动登录发消息为例）
  • 3分钟上手：用Apollo Save Tool玩转你的PS4游戏存档
  • MTK ISP 图像质量调优实战：从RAW图仿真到参数固化
  • AP-0316 语音处理模组 —— 安防设备专用高性能声学处理技术方案
  • 2026十大建议考的经济学专业证书有哪些
  • 2026年5月太原毛坯/全屋整装/新房装修/旧房翻新/毛坯装修公司指南：从行业焦虑到可靠选择的逻辑推演 - 2026年企业推荐榜
  • SAP PS项目模板保姆级搭建指南：从CJ91到CN13，手把手教你构建企业级OPA
  • 从‘登录按钮’到‘游戏手柄’：用Qt PushButton信号与槽实现3种意想不到的交互（含完整源码）
  • 别再只用ping了！用TCP Traceroute排查服务器网络问题的保姆级教程（Win/Mac/Linux全平台）
  • 如何在Dev-C++中设置默认编译器
  • 从仿真到调试：FSDB与VPD波形文件的生成与高效查看指南
  • 从网页到知识库：如何用MarkDownload重塑你的信息收集流程
  • 2026年太原高考复读与全日制辅导机构深度横评｜官方对接渠道与选校避坑指南 - 企业名录优选推荐
  • Zutilo：为Zotero研究者量身打造的高效文献管理增强插件
  • 英雄联盟Akari工具包：3分钟快速上手终极游戏助手指南
  • Gemini Deep Research在学术文献综述中的失效场景：来自Nature子刊审稿人的真实复现失败案例（含12篇论文验证数据）
  • 百度文库文档免费保存：3步轻松获取纯净PDF文件
  • 别光看理论了！手把手带你复现三个经典逆向案例：Python字节码、Linux SUID提权与CrackMe破解
  • FanControl免费终极指南：一键掌控电脑风扇，告别噪音烦恼！
  • 多租户认证授权框架：Spring Security与RBAC的工程实践
  • CXL内存扩展与IBEX架构的带宽效率优化
  • 青岛银行员工才艺大赛｜iPad评委打分系统案例
  • 实战避坑：为什么你写的‘if-else’语法总有二义性？从‘悬空else’问题看文法设计
  • Aurora公式字体调校实战：攻克Times New Roman在Word中的显示难题
  • 告别Qt Creator！在VS2017社区版里配置Qt 5.14开发环境（附环境变量避坑指南）
  • 使用代码输出1-120内所有的素数
  • 光学鼠标技术演进与核心工作原理解析
  • 青岛合创惠民起重设备：崂山区专业的汽车吊租赁公司选哪家 - LYL仔仔