GESP 六级 · 2026 真题

下列关于 C++ 中类的描述，正确的是（）。

下列代码中，s1->draw(); 和 s2->draw(); 输出不同结果的主要原因是（）。

01class Shape {
02public:
03    virtual void draw() {
04        cout << "绘制图形" << endl;
05    }
06
07    virtual ~Shape() {}
08};
09
10class Circle : public Shape {
11public:
12    void draw() override {
13        cout << "绘制圆形" << endl;
14    }
15};
16
17class Rectangle : public Shape {
18public:
19    void draw() override {
20        cout << "绘制矩形" << endl;
21    }
22};
23
24int main() {
25    Shape* s1 = new Circle();
26    Shape* s2 = new Rectangle();
27
28    s1->draw();
29    s2->draw();
30
31    delete s1;
32    delete s2;
33    return 0;
34}

下面的代码在 main() 中有一行会导致编译错误，请找出来。

01class Pet {
02public:
03    Pet(string n, int a) : name(n), age(a) {}
04    string getName() { return name; }
05    void birthday() { age++; }
06private:
07    string name;
08    int age;
09};
10
11int main() {
12    Pet cat("奶茶", 2);
13    cout << cat.getName();      // ①
14    cat.birthday();             // ②
15    cat.name = "大橘";          // ③
16    cout << cat.getName();      // ④
17}

游乐园的过山车每次限坐 $4$ 人，用循环队列管理排队（容量 MAX=5，空一格判断满）。下面代码执行后，循环队列是否已满？rear 的值是多少？

01const int MAX = 5;
02int queue[MAX];
03int front = 0, rear = 0;
04
05// 入队
06void enqueue(int x) {
07    queue[rear] = x;
08    rear = (rear + 1) % MAX;
09}
10// 出队
11void dequeue() {
12    front = (front + 1) % MAX;
13}
14
15int main() {
16    enqueue(1); enqueue(2); enqueue(3); enqueue(4);
17    dequeue(); dequeue();
18    enqueue(5); enqueue(6);
19}

在以下计算机系统应用场景中，最适合使用循环队列的是（）。

在二叉搜索树（BST）中，若中序遍历的序列为 {1, 2, 3, 4, 5}，且先序遍历的第一个序列元素为 3，则下列说法正确的是（）。

某二叉树共有 $10$ 个结点，记为 A~J，已知它的先序遍历序列为：A B D H I E C F J G，中序遍历序列为：H D I B E A F J C G，则该二叉树的后序遍历序列是（）。

下列关于树的遍历的说法中，正确的一项是（）。

有 $6$ 个字符，它们出现的次数分别为：{2, 3, 3, 4, 6, 8}，现在用哈夫曼编码为这些字符编码，最小加权路径长度 WPL（每个字符的出现次数 $\times$ 它的编码长度，再把每个字符结果加起来）的值为（）。

对 $n$ 个不同符号的符号进行哈夫曼编码。若生成的哈夫曼树共有 $115$ 个结点，则 $n$ 的值是（）。

关于格雷编码（Gray Code），下列说法正确的是（）。

给定一棵二叉树，采用广度优先搜索（BFS）算法，返回右视图所有节点的值。其中右视图定义为：二叉树的右视图是从树的右侧看过去时可见的节点集合，即右视图中的每个节点都是某一层中最右侧的节点。

01struct TreeNode {
02    int val;
03    TreeNode* left;
04    TreeNode* right;
05    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
06};
07
08vector<int> rightSideView(TreeNode* root) {
09    unordered_map<int, int> rightmostValueAtDepth;
10    int max_depth = -1;
11
12    queue<TreeNode*> nodeQueue;
13    queue<int> depthQueue;
14    nodeQueue.push(root);
15    depthQueue.push(0);
16
17    while (!nodeQueue.empty()) {
18        TreeNode* node = nodeQueue.front(); nodeQueue.pop();
19        int depth = depthQueue.front(); depthQueue.pop();
20
21        if (node != NULL) {
22            max_depth = max(max_depth, depth);
23            rightmostValueAtDepth[depth] = node->val;
24            nodeQueue.push(node->left);
25            nodeQueue.push(node->right);
26            depthQueue.push(____________);
27            depthQueue.push(____________);
28        }
29    }
30
31    vector<int> rightView;
32    for (int depth = 0; ____________; ++depth) {
33        rightView.push_back(rightmostValueAtDepth[depth]);
34    }
35    return rightView;
36}

下列关于树的深度优先搜索（DFS）的说法中，正确的是（）。

小朋友们去邻里拜年，每个家里有不同数量的糖果。规则是：不能连续进入两个相邻的房子（即不能同时取相邻两家的糖果）。目标是拿到最多糖果。以下代码实现，请补全横线。

01int visit(vector<int>& nums) {
02    if (nums.empty()) {
03        return 0;
04    }
05    int size = nums.size();
06    if (size == 1)
07        return nums[0];
08
09    vector<int> dp = vector<int>(size, 0);
10    dp[0] = nums[0];
11    dp[1] = max(nums[0], nums[1]);
12
13    for (int i = 2; i < size; i++) {
14        dp[i] = ____________; // 在此处填写代码
15    }
16
17    return dp[size - 1];
18}

元宵节晚上，小朋友沿着一条发光石板路前进，每次可向前走 $1$ 块或 $2$ 块石板。动态规划定义如下：dp[i] = dp[i - 1] + dp[i - 2]，下面关于 dp[i] 的含义最合适的是（）。

下面定义了一个表示二维坐标点的类 Point，并提供了一个带参数的构造函数，但第②行 Point b; 会调用编译器自动生成的默认构造函数，将 b.x 和 b.y 初始化为 0.0，程序可以正常运行。

01class Point {
02public:
03    double x, y;
04    Point(double px, double py) : x(px), y(py) {}
05    void print() {
06        cout << "(" << x << ", " << y << ")";
07    }
08};
09
10int main() {
11    Point a(3.0, 4.0);   // ①
12    Point b;             // ②
13    a.print();
14}

C++ 中的继承支持单继承和多继承，但子类无法直接访问父类的私有成员。

对如下结构的树，执行 travel 函数，输出结果是 1 2 3 4 5。

01        1
02       / \
03      2   3
04     / \
05    4   5
06
07struct Node {
08    int val;
09    Node *left, *right;
10    Node(int v) : val(v), left(nullptr), right(nullptr) {}
11};
12
13void travel(Node* root) {
14    if (!root) return;
15    stack<Node*> s;
16    s.push(root);
17
18    while (!s.empty()) {
19        Node* cur = s.top(); s.pop();
20        cout << cur->val << " ";
21
22        if (cur->right) s.push(cur->right);
23        if (cur->left) s.push(cur->left);
24    }
25}

若所有字符出现频率相同，则哈夫曼编码一定会得到完全二叉树。

哈夫曼编码是一种变长的前缀编码，在解码时不需要额外的分隔符就能唯一还原，这是因为在哈夫曼树中，任何一个字符的叶子结点都不会成为另一个字符结点的祖先。

在 C++ 中使用一维数组 vector<int> tree 存储按层序遍历的完全二叉树时，若根节点存储在 tree[0]，则对于任意非空节点 tree[i]，其右孩子（如果存在）必然位于 tree[2*i+2]。

在 C++ 中使用栈来非递归地实现二叉树的前序遍历时，为了保证遍历顺序正确，在处理完当前结点后，应该先将该结点的左孩子压入栈中，然后再将右孩子压入栈中。

设二叉树共有 $n$ 个结点，函数 preorderTraversal 以下代码的时间复杂度为 $O(n)$，空间复杂度为 $O(n)$。

01void preorder(TreeNode* root, vector<int>& res) {
02    if (root == nullptr) {
03        return;
04    }
05    res.push_back(root->val);
06    preorder(root->left, res);
07    preorder(root->right, res);
08}
09
10vector<int> preorderTraversal(TreeNode* root) {
11    vector<int> res;
12    preorder(root, res);
13    return res;
14}

下列代码实现了一个 0-1 背包的一维动态规划代码，内层循环是经典的逆序写法。若将内层循环改成正序遍历（即 for (int j = w[i]; j <= W; j++)），仍能得到正确答案。

01int main() {
02    int W = 5;
03    int w[] = {2, 3, 4};
04    int v[] = {10, 1, 1};
05    int n = 3;
06    int dp[6] = {0};
07
08    for (int i = 0; i < n; i++) {
09        for (int j = W; j >= w[i]; j--) {
10            dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
11        }
12    }
13    cout << dp[W];
14}

在动态规划问题中，状态空间相同且没有重复计算的情况下，“状态转移方程+递推”与“递归+记忆化搜索”的时间复杂度通常相同。