2025年6月GESP 6级C++真题_含答案与解析

一单选题

共 15 道每题 2 分共计 30 分

第 1 题

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

A

继承

B

封装

C

多态

D

链接

第 2 题

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

class Animal {
public:
    std::string name;
 
    Animal(std::string str) : name(str) {
        std::cout << "Animal created\n";
    }
 
    virtual void speak() {
        std::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 {
        std::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()

第 3 题

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

A

输出 Animal speaks

B

输出 Dog barks

C

编译错误

D

程序崩溃

第 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

第 5 题

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

A

rear == front

B

(rear + 1) % maxSize == front

C

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

D

(rear - 1) == front

第 6 题

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

A

完美二叉树

B

完全二叉树

C

完满二叉树

D

平衡二叉树

第 7 题

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

A

$(i - 1) / 2$

B

$i + 1$

C

$i \times 2$

D

$2 \times i + 1$

第 8 题

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

A

ADFGEHMZ

B

ADFGHMEZ

C

AFDGEMZH

D

AFDHZMEG

第 9 题

第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

第 10 题

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

A

100

B

111

C

110

D

001

第 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);

第 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) {
            ________________________
            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();

第 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);

第 14 题

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

A

子问题相互独立，不重叠

B

问题包含重叠子问题和最优子结构

C

只能从底至顶迭代求解

D

必须使用递归实现，不能使用迭代

第 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

这段代码计算的是最小重量而非最大价值

CCF GESP 2025年6月认证 C++ 6级