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

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

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

一、单选题

1. 单选题

在一个循环队列中, front 是指向队头的指针, rear 指向队尾的指针,队列最大容量为 maxSize 。

判断队列已满的条件是?( )


  • A

    rear == front

  • B

    (rear + 1) % maxSize == front

  • C

    (rear - 1 + maxSize) % maxSize == front

  • D

    (rear - 1) == front

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

下列哪一项不是面向对象编程的基本特征?( )

  • A 继承
  • B 封装
  • C 多态
  • D 链接
查看答案与解析
答案:D
这道题暂未补解析。
3. 单选题

为了让 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
这道题暂未补解析。
4. 单选题

代码同上一题,代码执行结果是?( )

  • A 输出 Animal speaks
  • B 输出 Dog barks
  • C 编译错误
  • D 程序崩溃
查看答案与解析
答案:B
这道题暂未补解析。
5. 单选题

以下关于栈和队列的代码,执行后输出是?( )

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
这道题暂未补解析。
6. 单选题

( )只有最底层的节点未被填满,且最底层节点尽量靠左填充?

  • A 完美二叉树
  • B 完全二叉树
  • C 完满二叉树
  • D 平衡二叉树
查看答案与解析
答案:B
这道题暂未补解析。
7. 单选题

在使用数组表示完全二叉树时,如果一个节点的索引为 i(从 0 开始计数),那么其左子节点的索引通常是?( )

  • A (i - 1) / 2
  • B i +1
  • C i * 2
  • D 2 * i + 1
查看答案与解析
答案:D
解析:

使用数组表示完全二叉树时,通常按照层次遍历的顺序存储节点。

假设根节点的索引为 0,对于任意节点索引 i,其左子节点的索引为 2*i+1,其右子节点的索引为 2*i+2。

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: 010b: 011c: 00d: 10e: 11
  • B a: 00b: 10c: 011d: 100e: 111
  • C a: 10b: 01c: 011d: 100e: 111
  • D a: 100b: 01c: 011d: 100e: 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. 单选题

给定 个物品和一个最大承重为 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
这道题暂未补解析。

二、判断题

16. 判断题

构造函数可以被声明为 virtual。( )

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

给定一组字符及其出现的频率,构造出的哈夫曼树是唯一的。( )

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

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

  • A对
  • B错
查看答案与解析
答案:对
解析:

使用环形数组实现队列时,出队操作只需移动队首指针并返回该位置的元素,无需移动其他元素,因此时间复杂度为O(1)。

在普通数组中,删除首元素需要将所有后续元素向前移动一位,时间复杂度为O(n)。而环形数组通过维护队首和队尾指针,出队时只需移动指针,避免了数据移动。

因此本题说法是正确。

19. 判断题

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

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

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

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

执行下列代码, 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;
}
  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。
22. 判断题

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

class Parent {
    private:
        int value = 100;
};
class Child : public Parent {
    public:
        int get_private_val() {
            return value; // 尝试访问父类的私有成员
        }
};
  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
23. 判断题

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

#include <vector>
std::vector<int> tree = {1, 2, 3, 4, -1, 6, 7};
  • A对
  • B错
查看答案与解析
答案:错
这道题暂未补解析。
24. 判断题

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

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

下面代码采用动态规划求解零钱兑换问题:给定 n 种硬币,第 i 种硬币的面值为 coins[i - 1] ,目标金额为 amt ,每种硬币可以重复选取,求能够凑出目标金额的最少硬币数量;如果不能凑出目标金额,返回 -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;
}
  • A对
  • B错
查看答案与解析
答案:对
这道题暂未补解析。

三、简答题

26. 简答题

学习小组

时间限制:1 s,内存限制:512 MB

【问题描述】

班主任计划将班级里的 n 名同学划分为若干个学习小组,每名同学都需要分入某一个学习小组中。观察发现,如果一个学习小组中恰好包含 k 名同学,则该学习小组的讨论积极度为 ak。

给定讨论积极度 a1、a2、……、an,请你计算将这 n 名同学划分为学习小组的所有可能方案中,讨论积极度之和的最大值。

【输入描述】

第一行,一个正整数 n,表示班级人数。

第二行,n 个非负整数 a1、a2、……、an,表示不同人数学习小组的讨论积极度。

【输出描述】

输出共一行,一个整数,表示所有划分方案中,学习小组讨论积极度之和的最大值。

【样例输入1】

4
1 5 6 3

【样例输出1】

10

【样例输入2】

8
0 2 5 6 4 3 3 4

【样例输出2】

12

【数据范围】

对于40%测试点,保证 1 <= n <= 10。

对于所有测试点,保证 1 <= n <= 1000,0 <= ai <= 10000。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;iostream&gt; using namespace std; const int N = 1005; int n, a[N]; int main() { cin &gt;&gt; n;     for (int i = 1; i &lt;= n; i++) {      cin &gt;&gt; a[i];         for (int j = 1; j &lt; i; j++)             a[i] = max(a[i], a[j] + a[i - j]);     }     cout &lt;&lt; a[n] &lt;&lt; endl;     return 0; }</pre>
这道题暂未补解析。
27. 简答题

最大因数

时间限制:1 s,内存限制:512 MB

【问题描述】

给定一棵有 10^9 个结点的有根树,这些结点依次以 1、2、……、10^9编号,根结点的编号为 1。

对于编号为 k(2 <= k <= 10^9)的结点,其父结点的编号为 k 的因数中除 k 以外最大的因数。

现在有 q 组询问,第 i(1<= i  <= q)组询问给定 xi、yi,请你求出编号分别为 xi、yi 的两个结点在这棵树上的距离。

两个结点之间的距离是连接这两个结点的简单路径所包含的边数。

【输入描述】

第一行,一个正整数 q,表示询问组数。

接下来 q 行,每行两个正整数 xi、yi,表示询问结点的编号。

【输出描述】

输出共 q 行,每行一个整数,表示结点 xi、yi 之间的距离。

【样例输入1】

3
1 3
2 5
4 8

【样例输出1】

1
2
1

【样例输入2】

1
120 650

【样例输出2】

9

【数据范围】

对于60%的测试点,保证 1 <= xi、yi <= 1000。

对于所有测试点,保证 1 <= q <= 1000,1 <= xi、yi <= 10^9。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;iostream&gt; #include &lt;algorithm&gt; using namespace std; const int N = 50; int a[N], cnta, b[N], cntb; int f[N], t, q; void factorize(int x, int a[], int &amp;cnt) {     a[0] = x;     t = 0;     for (int i = 2; i * i &lt;= x; i++)         while (x % i == 0) {             f[++t] = i;             x /= i;         }     if (x &gt; 1)         f[++t] = x;     for (int i = 1; i &lt;= t; i++)         a[i] = a[i - 1] / f[i];     cnt = t; } int main() {     cin &gt;&gt; q;     while (q--) {         int x, y;         cin &gt;&gt; x &gt;&gt; y;         factorize(x, a, cnta);         factorize(y, b, cntb);         int px = 0, py = 0;         while (a[px] != b[py]) {             if (a[px] &gt; b[py])                 px++;             else                 py++;         }         cout &lt;&lt; px + py &lt;&lt; endl;     }     return 0; }</pre>
这道题暂未补解析。