首页 › 试卷 › GESP编程能力等级认证 › GESP-C++六级 › 2024年12月CCF-GESP编程能力等级认证C++编程六级真题

2024年12月CCF-GESP编程能力等级认证C++编程六级真题 VIP

GESP-C++六级 共 27 题 2024 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

面向对象编程(OOP)是一种特殊的程序设计方法。下面( )不是重要的OOP特性。

  • A 抽象
  • B 封装
  • C 继承
  • D 模块化
查看答案与解析
答案:D
这道题暂未补解析。
2. 单选题

以下关于C++中类的说法,哪一项是正确的?

  • A 类中定义的所有成员变量和成员函数默认是 public 访问权限。
  • B 类的构造函数必须显式声明返回类型为 void 。
  • C 在C++中,类的数据一般设置为私有,其公有成员函数提供访问私有数据的唯一途径。
  • D 同一个类的实例有各自的成员数据和成员函数。
查看答案与解析
答案:C
这道题暂未补解析。
3. 单选题

以下C++代码段中存在语法错误或逻辑错误,( )是正确的。

#include <iostream>
using namespace std;
class MyClass {
public:
	MyClass() {
		cout << "Constructor called!" << endl;
	}
	void display() {
		cout << "Display function called!" << endl;
	}
};
int main() {
	MyClass* obj = NULL;
	obj->display();
	return 0;
}
  • A NULL 在C++中无法用于指针初始化,应使用 nullptr 。
  • B obj 的定义应该是 MyClass obj; 而不是指针类型。
  • C obj->display() 语句存在空指针访问错误, obj 应该初始化为一个有效的对象。
  • D obj->display() 语句会调用 display() 函数,但它没有输出任何内容。
查看答案与解析
答案:C
这道题暂未补解析。
4. 单选题

阅读以下代码,下面哪一项是正确的?

void processData() {
	stack<int> s;
	queue<int> q;
	for (int i = 1; i <= 5; ++i) {
		s.push(i);
		q.push(i);
	}
	while (!s.empty()) {
		cout << "Stack pop: " << s.top() << endl;
		s.pop();
	}
	while (!q.empty()) {
		cout << "Queue pop: " << q.front() << endl;
		q.pop();
	}
}
  • A 栈 s 的输出顺序是 1 2 3 4 5 ,队列 q 的输出顺序是 5 4 3 2 1 。
  • B 栈 s 的输出顺序是 5 4 3 2 1 ,队列 q 的输出顺序是 1 2 3 4 5 。
  • C 栈 s 的输出顺序是 1 2 3 4 5 ,队列 q 的输出顺序是 1 2 3 4 5 。
  • D 栈 s 的输出顺序是 1 2 3 4 5 ,队列 q 的输出顺序是 1 2 3 4 5 ,程序不会正常执行。
查看答案与解析
答案:B
这道题暂未补解析。
5. 单选题

N 个节点的双向循环链,在其中查找某个节点的平均时间复杂度是( )。

  • A O(1)
  • B O(N)
  • C O(logN)
  • D O(N3)
查看答案与解析
答案:B
这道题暂未补解析。
6. 单选题

以下关于树的说法,( )是正确的。

  • A 在一棵二叉树中,叶子结点的度一定是2。
  • B 满二叉树中每一层的结点数等于 O(2 (层数−1))。
  • C 在一棵树中,所有结点的度之和等于所有叶子结点的度之和。
  • D 一棵二叉树的先序遍历结果和中序遍历结果一定相同。
查看答案与解析
答案:B
这道题暂未补解析。
7. 单选题

已知字符集 {A, B, C, D} 的出现频率如下表所示:

根据哈夫曼编码法,下面( )是正确的哈夫曼树。

  • A
     ABCD
     / \
    A   BCD
        / \
       D   BC
          / \
         B   C
  • B
     ABCD
     / \
    A   BCD
        / \
       B   CD
          / \
         C   D
  • C
     ABCD
     / \
    D   ABC
        / \
       A   BC
          / \
         B   C
  • D
     ABCD
     / \
    C   ABC
        / \
       B   AD
          / \
         A   D
查看答案与解析
答案:A
这道题暂未补解析。
8. 单选题

上一题中各字符的哈夫曼编码是( )。

  • A A: 0, B: 10, C: 110, D: 111
  • B A: 0, B: 10, C: 11, D: 10
  • C A: 0, B: 101, C: 100, D: 11
  • D A: 11, B: 10, C: 01, D: 00
查看答案与解析
答案:C
这道题暂未补解析。
9. 单选题

( )是 3 位格雷编码。

  • A 000 001 011 010 110 111 101 100
  • B 000 001 010 011 100 101 110 111
  • C 000 001 100 101 011 010 111 110
  • D 000 010 001 011 100 110 101 111
查看答案与解析
答案:A
这道题暂未补解析。
10. 单选题

根据下面二叉树和给定的代码,

#include <iostream>
using namespace std;

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* search(TreeNode* root, int val) {
	cout << root->val << " ";
	if (root == NULL || root->val == val) return root;
	
	if (val < root->val)
		return search(root->left, val);
	else
		return search(root->right, val);
}

给定以下二叉搜索树,调用函数 search(root,7) 时,输出的结果是( )。

    5
   / \
  3   7
 / \ / \
2  4 6  8
  • A 5 3 7
  • B 5 7
  • C 2 3 4 5 6 7
  • D 8 7
查看答案与解析
答案:B
这道题暂未补解析。
11. 单选题

阅读以下二叉树的深度优先搜索算法,横线上应填写( )。

void dfs(TreeNode* root) {
	if (root == nullptr)
		return;
		
	stack<TreeNode*> s;
	s.push(root);
	while (!s.empty()) {
		———————————————————————— // 在此处填入代码
		cout << node->value << " ";
		
		if (node->right) s.push(node->right);
		if (node->left) s.push(node->left);
	}
}
  • A TreeNode* node = s.top();
  • B TreeNode* node = s.top(); s.pop();
  • C TreeNode* node = s.front();
  • D TreeNode* node = s.front(); s.pop();
查看答案与解析
答案:B
这道题暂未补解析。
12. 单选题

阅读以下二叉树的广度优先搜索的代码,横线上应填写( )。

#include <queue>
void bfs(TreeNode* root) {
	if (root == NULL) return;
	
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty()) {
		———————————————————————— // 在此处填入代码
		cout << node->val << " ";
		if (node->left) {
			q.push(node->left);
		}
		if (node->right) {
			q.push(node->right);
		}
	}
}
  • A TreeNode* node = q.top();
  • B TreeNode* node = q.top(); q.pop();
  • C TreeNode* node = q.front();
  • D TreeNode* node = q.front(); q.pop();
查看答案与解析
答案:D
这道题暂未补解析。
13. 单选题

使用上题中的宽度优先搜索算法遍历以下这棵树,可能的输出是( )。

  1
   / \
  2   3
 / \   \
8   9   6
   / \   \
  4   5   7
  • A 1 2 8 9 4 5 3 6 7
  • B 1 2 3 4 5 6 6 8 9
  • C 1 2 3 8 9 6 4 5 7
  • D 8 4 5 9 2 1 3 6 7
查看答案与解析
答案:C
这道题暂未补解析。
14. 单选题

以下关于动态规划的描述,( )是正确的。

  • A 动态规划适用于没有重叠子问题的优化问题。
  • B

    动态规划要求问题具有最优子结构和无后效性。

  • C

    动态规划通常通过递归来实现。

  • D

    动态规划与贪心算法不同,贪心算法不适用于有重叠子问题的问题。

查看答案与解析
答案:B
这道题暂未补解析。
15. 单选题

假设背包的最大容量 W=8kg,共有有 4 个物品可供选择,4个物品的重量分别为weights=[2,3,5,7],对应的价值分别为 values=[30,40,60,80],则该0/1背包问题中,背包的最大价值为( )。

  • A 70
  • B 90
  • C 100
  • D 120
查看答案与解析
答案:C
这道题暂未补解析。

二、判断题

16. 判断题

构造函数是一种特殊的类成员函数,构造函数的名称和类名相同。但通过函数重载,可以创建多个同名的构造函数,条件是每个构造函数的参数列表不同。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
17. 判断题

类的静态成员函数既能访问类的静态数据成员,也能访问非静态数据成员。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
18. 判断题

栈中元素的插入和删除操作都在栈的顶端进行,所以方便用单向链表实现。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
19. 判断题

下面代码构建的树一定是完全二叉树:

struct TreeNode {
	int value;
	TreeNode* left;
	TreeNode* right;
};

TreeNode* buildCompleteBinaryTree() {
	TreeNode* root = new TreeNode{1};
	root->left = new TreeNode{2};
	root->right = new TreeNode{3};
	root->left->left = new TreeNode{4};
	root->left->right = new TreeNode{5};
	root->right->left = new TreeNode{6};
	return root;
}
  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
20. 判断题

在二叉排序树中,左子树所有节点的值都大于根节点的值,右子树所有节点的值都小于根节点的值。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
21. 判断题

在生成一个派生类的对象时,只调用派生类的构造函数。

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
22. 判断题

下面的代码实现了二叉树的前序遍历,它通过递归方法访问每个节点并打印节点值。

void preorder(TreeNode* root) {
	if (root == NULL) return;
	cout << root->val << " ";
	preorder(root->left);
	preorder(root->right);
}


  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
23. 判断题

宽度优先搜索算法(BFS)保证了每个节点在最短路径的情况下被访问。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
24. 判断题

在解决简单背包问题时,动态规划的状态转移方程如下:

dp[i][w] = max(dp[i-1][w], dp[i-1][w - weights[i-1]] + values[i-1]);

该方程表示:在考虑第 i 个物品时,当前背包容量为 w ,如果不放物品 i ,则最大价值是 dp[i-1][w] ;如果放入物品 i ,则最大价值是 dp[i-1][w - weights[i-1]] + values[i-1] ,其中数组 weights 和 values 分别表示所有物品的重量和价值,数组下标从 0 开始。

  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
25. 判断题

栈中元素的插入和删除操作都在栈的顶端进行,所以方便用双向链表比单向链表更合适表实现。(2025.12-6)

  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。

三、简答题

26. 简答题

树上游走

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨有一棵包含无穷节点的二叉树(即每个节点都有左儿子节点和右儿子节点;除根节点外,每个节点都有父节点),其中根节点的编号为 1,对于节点 i ,其左儿子的编号为 2×i,右儿子的编号为 2×i+1。

小杨会从节点 s 开始在二叉树上移动,每次移动为以下三种移动方式的任意一种:

第1种移动方式: 如果当前节点存在父亲节点,向上移动到当前节点的父亲节点,否则不移动;

第2种移动方式: 移动到当前节点的左儿子;

第3种移动方式: 移动到当前节点的右儿子。

小杨想知道移动 n 次后自己所处的节点编号。数据保证最后的所处的节点编号不超过 1012。

输入格式

第一行包含一个正整数 n,s,代表移动次数和初始节点编号。

第二行包含一个长度为 n 且仅包含大写字母 U,L,R 的字符串,代表每次移动的方式,其中 U 代表第1种移动方式,L 代表第2种移动方式,R代表第3种移动方式。

输出格式

输出一个正整数,代表最后所处的节点编号。

输入样例

3 2
URR

输出样例

7

样例解释

小杨的移动路线为 2-1-3-7。

对于全部数据,保证有 1≤n≤106,1≤s≤1012。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;bits/stdc++.h&gt; #define ll long long using namespace std; const ll INF = 1e12; int n; stack&lt;char&gt; st; string c; ll s; int main(){ cin &gt;&gt; n &gt;&gt; s &gt;&gt; c; for(int i = 0; i &lt; n; i ++){ if(c[i] == 'U'){ if(s == 1) continue; if(st.size()){ st.pop(); continue; } s &gt;&gt;= 1; }else if(c[i] == 'L'){ if((s &lt;&lt; 1) &gt; INF){ st.push('L'); continue; } s = s &lt;&lt; 1; }else{ if((s &lt;&lt; 1 | 1) &gt; INF){ st.push('R'); continue; } s = s &lt;&lt; 1 | 1; } } cout &lt;&lt; s &lt;&lt; "\n"; return 0; }</pre>
这道题暂未补解析。
27. 简答题

运送物资

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨管理着 m 辆货车,每辆货车每天需要向 A 市和 B 市运送若干次物资。小杨同时拥有 n 个运输站点,这些站点位于 A 市和 B 市之间。

每次运送物资时,货车从初始运输站点出发,前往 A 市或 B 市,之后返回初始运输站点。A 市、B 市和运输站点的位置可以视作数轴上的三个点,其中 A 市的坐标为 0,B 市的坐标为 x ,运输站点的坐标为 p 且有 0<p<x,货车每次去 A 市运送物资的总行驶路程为 2p,去 B 市运送物资的总行驶路程为 2(x−p)。

对于第 i 个运输站点,其位置为 pi且至多作为 ci辆车的初始运输站点。小杨想知道,在最优分配每辆货车的初始运输站点的情况下,所有货车每天的最短总行驶路程是多少。

输入格式

第一行包含三个正整数 n,m,x,代表运输站点数量,货车数量和两市距离。

之后 n 行,每行包含两个正整数 pi,ci,代表第 i 个运输站点的位置和最多容纳车辆数。

之后 m 行,每行包含两个正整数 ai,bi,代表第 i 辆货车每天需要向 A 市运送 ai次物资,向 B 市运送 bi次物资。

输出格式

输出一个正整数,代表所有货车每天的最短总行驶路程。


输入样例

3 4 10
1 1
2 1
8 3
5 3
7 2
9 0
1 10000

输出样例

40186

样例解释

第 1 辆车的初始运输站点为站点 3,第 2 辆车的初始运输站点为站点 2。第 3 辆车的初始运输站点为站点 1,第 4 辆车的初始运输站点为站点 3。此时总行驶路程最短,为 40186。

对于全部数据,保证有 1≤n,m≤105,2≤x≤108,0<pi<x,1≤ci≤105,0≤ai,bi≤105。数据保证∑ci≥m。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false;">#include&lt;bits/stdc++.h&gt; using namespace std; #define ll long long const int N = 1e5+10; int n,m; ll x; vector&lt;pair&lt;int,int&gt; &gt; st; int a[N],b[N]; int main(){ cin&gt;&gt;n&gt;&gt;m&gt;&gt;x; for(int i=1;i&lt;=n;i++){ int p,c; cin&gt;&gt;p&gt;&gt;c; st.push_back(make_pair(p,c)); } sort(st.begin(),st.end()); for(int i=1;i&lt;=m;i++){ cin&gt;&gt;a[i]&gt;&gt;b[i]; } vector&lt;pair&lt;int,int&gt; &gt; neg,pos; ll res=0; for(int i=1;i&lt;=m;i++){ if(a[i]&gt;=b[i]) pos.push_back(make_pair(a[i]-b[i],i)); else{ neg.push_back(make_pair(a[i]-b[i],i)); } res+=1ll*b[i]*x; } sort(neg.begin(),neg.end()); sort(pos.begin(),pos.end()); reverse(pos.begin(),pos.end()); int l=0,r=n-1; for(auto i:neg){ while(r&gt;=1&amp;&amp;st[r].second==0)r--; res+=1ll*(a[i.second]-b[i.second])*st[r].first; st[r].second-=1; } for(auto i:pos){ while(l&lt;=n&amp;&amp;st[l].second==0)l++; res+=1ll*(a[i.second]-b[i.second])*st[l].first; st[l].second-=1; } cout&lt;&lt;res*2&lt;&lt;"\n"; }</pre>
这道题暂未补解析。