#TK1168. 2025年9月CCF-GESP编程能力等级认证C++编程六级真题

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

GESP C++ 六级 2025年09月考试试卷

1 单选题（每题 2 分，共 30 分）

第 1 题

下列关于类的说法，错误的是( )。 {{ select(1) }}

  • 构造函数不能声明为虚函数，但析构函数可以。
  • 函数参数如声明为类的引用类型，调用时不会调用该类的复制构造函数。
  • 静态方法属于类而不是某个具体对象，因此推荐用 类名::方法(...) 调用。
  • 不管基类的析构函数是否是虚函数，都可以通过基类指针/引用正确删除派生类对象。

第 2 题

假设变量veh是类Car的一个实例，我们可以调用veh.move()，是因为面向对象编程有( )性质。

class Vehicle {
private: 
    string brand;
public: 
    Vehicle(string b) : brand(b) {}
    void setBrand(const string& b) { brand = b; } 
    string getBrand() const { return brand; }
    void move() const { 
        cout << brand << " is moving..." << endl;
    }
};

class Car : public Vehicle {
private:
    int seatCount;
public:
    Car(string b, int seats) : Vehicle(b), seatCount(seats) {}
    void showInfo() const {
        cout << "This car is a " << getBrand() << " with " << seatCount << " seats." << endl;
    }
};

{{ select(2) }}

  • 继承 (Inheritance)
  • 封装 (Encapsulation)
  • 多态 (Polymorphism)
  • 链接 (Linking)

第 3 题

下面代码中v1和v2调用了相同接口move()，但输出结果不同，这体现了面向对象编程的( )特性。

class Vehicle {
private:
    string brand;
public: 
    Vehicle(string b) : brand(b) {}
    void setBrand(const string& b) { brand = b; } 
    string getBrand() const { return brand; }
    virtual void move() const { 
        cout << brand << " is moving..." << endl;
    }
};

class Car : public Vehicle {
private:
    int seatCount;
public: 
    Car(string b, int seats) : Vehicle(b), seatCount(seats) {}
    void showInfo() const { 
        cout << "This car is a " << getBrand() << " with " << seatCount << " seats." << endl;
    }
    void move() const override {
        cout << getBrand() << " car is driving on the road!" << endl;
    }
};

class Bike : public Vehicle {
public: 
    Bike(string b) : Vehicle(b) {}
    void move() const override { 
        cout << getBrand() << " bike is cycling on the path!" << endl;
    }
};

int main() { 
    Vehicle* v1 = new Car("Toyota", 5);
    Vehicle* v2 = new Bike("Giant");
    v1->move(); 
    v2->move(); 
    delete v1;
    delete v2;
    return 0;
}

{{ select(3) }}

  • 继承 (Inheritance)
  • 封装 (Encapsulation)
  • 多态 (Polymorphism)
  • 链接 (Linking)

第 4 题

栈的操作特点是( )。 {{ select(4) }}

  • 先进先出
  • 先进后出
  • 随机访问
  • 双端进出

第 5 题

循环队列常用于实现数据缓冲。假设一个循环队列容量为 5（即最多存放 4 个元素，留一个位置区分空与满），依次进行操作：入队数据1、2、3，出队1个数据，再入队数据4和5，此时队首到队尾的元素顺序是( )。 {{ select(5) }}

  • [2, 3, 4, 5]
  • [1, 2, 3, 4]
  • [3, 4, 5, 2]
  • [2, 3, 5, 4]

第 6 题

以下函数createTree()构造的树是什么类型？

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

TreeNode* createTree() {
    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);
    return root;
}

{{ select(6) }}

  • 满二叉树
  • 完全二叉树
  • 二叉排序树
  • 其他都不对

第 7 题

已知二叉树的中序遍历是 [D, B, E, A, F, C]，先序遍历是 [A, B, D, E, C, F]。请问该二叉树的后序遍历结果是( )。 {{ select(7) }}

  • [D, E, B, F, C, A]
  • [D, B, E, F, C, A]
  • [D, E, B, C, F, A]
  • [B, D, E, F, C, A]

第 8 题

完全二叉树可以用数组连续高效存储，如果节点从1开始编号，则对有两个孩子节点的节点i，( )。 {{ select(8) }}

  • 左孩子位于2i，右孩子位于2i+1
  • 完全二叉树的叶子节点可以出现在最后一层的任意位置
  • 所有节点都有两个孩子
  • 左孩子位于2i+1，右孩子位于2i+2

第 9 题

设有字符集{a, b, c, d, e, f}，其出现频率分别为 {5, 9, 12, 13, 16, 45}。哈夫曼算法构造最优前缀编码，以下哪一组可能是对应的哈夫曼编码？（非叶子节点左边分支记作 0，右边分支记作 1，左右互换不影响正确性）。 {{ select(9) }}

  • a: 00; b: 01; c: 10; d: 110; e: 111; f: 0
  • a: 1100; b: 1101; c: 100; d: 101; e: 111; f: 0
  • a: 000; b: 001; c: 01; d: 10; e: 110; f: 111
  • a: 10; b: 01; c: 100; d: 101; e: 111; f: 0

第 10 题

下面代码生成格雷编码，则横线上应填写( )。

vector<string> grayCode(int n) {
    if (n == 0) return {"0"}; 
    if (n == 1) return {"0", "1"};
    vector<string> prev = grayCode(n-1);
    vector<string> result;
    for (string s : prev) {
        result.push_back("0" + s);
    }
    for (_______________) { // 在此处填写代码
        result.push_back("1" + prev[i]);
    }
    return result;
}

{{ select(10) }}

  • int i = 0; i < prev.size(); i++
  • int i = prev.size()-1; i >= 0; i--
  • auto s : prev
  • int i = prev.size()/2; i < prev.size(); i++

第 11 题

请将下列树的深度优先遍历代码补充完整，横线处应填入( )。

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

______<TreeNode*> temp; // 在此处填写代码
void dfs(TreeNode* root) { 
    if (!root) return; 
    temp.push(root);
    while (!temp.empty()) {
        TreeNode* node = temp.top();
        temp.pop();
        cout << node->val << " "; 
        if (node->right) temp.push(node->right); 
        if (node->left) temp.push(node->left);
    }
}

{{ select(11) }}

  • vector
  • list
  • queue
  • stack

第 12 题

令n是树的节点数目，下列代码实现了树的广度优先遍历，其时间复杂度是( )。

void bfs(TreeNode* root) {
    if (!root) return;
    queue<TreeNode*> q;
    q.push(root); 
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop(); 
        cout << node->val << " "; 
        if (node->left) q.push(node->left);
        if (node->right) q.push(node->right);
    }
}

{{ select(12) }}

  • (O(1))
  • (O(n))
  • (O(n\log n))
  • (O(n^2))

第 13 题

在二叉排序树（Binary Search Tree, BST）中查找元素 50，从根节点开始：若根值为 60，则下一步应去搜索( )。 {{ select(13) }}

  • 左子树
  • 右子树
  • 随机
  • 根节点

第 14 题

删除二叉排序树中的节点时，如果节点有两个孩子，则横线处应填入( )，其中findMax和findMin分别为寻找树的最大值和最小值的函数。

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

TreeNode* deleteNode(TreeNode* root, int key) {
    if (!root) return nullptr; 
    if (key < root->val) {
        root->left = deleteNode(root->left, key);
    } else if (key > root->val) {
        root->right = deleteNode(root->right, key);
    } else { 
        if (!root->left) return root->right; 
        if (!root->right) return root->left; 
        TreeNode* temp = // 在此处填写代码
        root->val = temp->val;
        root->right = deleteNode(root->right, temp->val);
    }
    return root;
}

{{ select(14) }}

  • root->left
  • root->right
  • findMin(root->right)
  • findMax(root->left)

第 15 题

给定n个物品和一个最大承重为W的背包，每个物品有重量wt[i]和价值val[i]，每个物品只能选或不放。目标是选择若干个物品放入背包，使得总价值最大，且总重量不超过W。以下代码实现0-1背包问题，横线上应填写( )。

int knapsack(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) { 
            // 在此处填写代码
        }
    }
    return dp[W];
}

{{ select(15) }}

  • dp[w] = max(dp[w], dp[w] + val[i]);
  • dp[w] = dp[w - wt[i]] + val[i];
  • dp[w] = max(dp[w - 1], dp[w - wt[i]] + val[i]);
  • dp[w] = max(dp[w], dp[w - wt[i]] + val[i]);

2 判断题（每题 2 分，共 20 分）

第 16 题

当基类可能被多态使用，其析构函数应该声明为虚函数。( ) {{ select(16) }}

  • 正确
  • 错误

第 17 题

哈夫曼编码是最优前缀码，且编码结果唯一。( ) {{ select(17) }}

  • 正确
  • 错误

第 18 题

一个含有n个节点的完全二叉树，高度为 (\lfloor \log_2 n \rfloor + 1)。( ) {{ select(18) }}

  • 正确
  • 错误

第 19 题

在 C++ STL 中，栈（std::stack）的pop操作返回栈顶元素并移除它。( ) {{ select(19) }}

  • 正确
  • 错误

第 20 题

循环队列通过模运算循环使用空间。( ) {{ select(20) }}

  • 正确
  • 错误

第 21 题

一棵有n个节点的二叉树一定有 (n-1) 条边。( ) {{ select(21) }}

  • 正确
  • 错误

第 22 题

以下代码实现了二叉树的中序遍历。输入如下二叉树（结构：根为1，左孩子2、右孩子3；2的左孩子4、右孩子5；3的右孩子6），中序遍历结果是4 2 5 1 3 6。( )

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

void inorderIterative(TreeNode* root) { 
    stack<TreeNode*> st; 
    TreeNode* curr = root;
    while (curr || !st.empty()) { 
        while (curr) { 
            st.push(curr);
            curr = curr->left;
        }
        curr = st.top(); 
        st.pop();
        cout << curr->val << " ";
        curr = curr->right;
    }
}

{{ select(22) }}

  • 正确
  • 错误

第 23 题

下面代码实现的二叉排序树的查找操作时间复杂度是 (O(h))，其中 h 为树高。( )

TreeNode* searchBST(TreeNode* root, int val) {
    while (root && root->val != val) { 
        root = (val < root->val) ? root->left : root->right;
    }
    return root;
}

{{ select(23) }}

  • 正确
  • 错误

第 24 题

下面代码实现了动态规划版本的斐波那契数列计算，其时间复杂度是 (O(2^n))。( )

int fib_dp(int n) { 
    if (n <= 1) return n;
    vector<int> dp(n+1);
    dp[0] = 0;
    dp[1] = 1; 
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i-1] + dp[i-2];
    } 
    return dp[n];
}

{{ select(24) }}

  • 正确
  • 错误

第 25 题

有一排香蕉，每个香蕉有不同的甜度值。小猴子想吃香蕉，但不能吃相邻的香蕉。以下代码能找到小猴子吃到最甜的香蕉组合。( )

// bananas:香蕉的甜度
void findSelectedBananas(vector<int>& bananas, vector<int>& dp) {
    vector<int> selected; 
    int i = bananas.size() - 1;
    while (i >= 0) { 
        if (i == 0) { 
            selected.push_back(0); 
            break;
        }
        if (dp[i] == dp[i-1]) {
            i--;
        } else { 
            selected.push_back(i); 
            i -= 2;
        }
    }
    reverse(selected.begin(), selected.end());
    cout << "小猴子吃了第: ";
    for (int idx : selected) 
        cout << idx+1 << " ";
    cout << "个香蕉" << endl;
}

int main() {
    vector<int> bananas = {1, 2, 3, 1}; // 每个香蕉的甜度
    vector<int> dp(bananas.size());
    dp[0] = bananas[0];
    dp[1] = max(bananas[0], bananas[1]); 
    for (int i = 2; i < bananas.size(); i++) { 
        dp[i] = max(bananas[i] + dp[i-2], dp[i-1]);
    }
    findSelectedBananas(bananas, dp);
    return 0;
}

{{ select(25) }}

  • 正确
  • 错误
  1. Language
  2. 兼容模式
  3. 主题
  3. Worker 0, 58ms
  4. Powered by Hydro v5.0.0-beta.7 Community