#GESP2025036K. GESP-C++ 六级客观题202503K

GESP-C++ 六级客观题202503K

一、单选题（每题 22 分，共 3030 分）

1、1、​​在面向对象编程中，类是一种重要的概念。下面关于类的描述中，不正确的是（ ）。

{{ select(1) }}

  • 类是一个抽象的概念，用于描述具有相同属性和行为的对象集合。
  • 类可以包含属性和方法，属性用于描述对象的状态，方法用于描述对象的行为。
  • 类可以被实例化，生成具体的对象。
  • 类一旦定义后，其属性和方法不能被修改或扩展。

2、2、哈夫曼编码是一种数据压缩算法。以下关于哈夫曼编码的描述中，不正确的是（ ）。

{{ select(2) }}

  • 哈夫曼编码是一种变长编码，频率高的字符使用较短的编码，频率低的字符使用较长的编码。
  • 在构造哈夫曼树时，频率越低的字符离根节点越近，频率越高的字符离根节点越远。
  • 哈夫曼编码的生成过程基于贪心算法，每次选择频率最低的两个节点进行合并。
  • 哈夫曼编码是一种前缀编码，任何一个字符的编码都不会是另一个字符编码的前缀，因此可以实现唯一解 码。

3、3、以下代码实现了树的哪种遍历方式？

1. void traverse(TreeNode* root) {
2.     if (root == nullptr) return;
3.     cout << root->val << " ";
4.     traverse(root->left);
5.     traverse(root->right);
6. }

{{ select(3) }}

  • 前序遍历
  • 中序遍历
  • 后序遍历
  • 层次遍历

4、4、以下关于完全二叉树的代码描述，正确的是（ ）。

1. bool isCompleteTree(TreeNode* root) {
2.     if (root == nullptr) return true;
3.     queue<TreeNode*> q;
4.     q.push(root);
5.     bool hasNull = false;
6.     while (!q.empty()) {
7.         TreeNode* node = q.front();
8.         q.pop();
9.         if (node == nullptr) {
10.            hasNull = true;
11.        } else {
12.            if (hasNull) return false;
13.            q.push(node->left);
14.            q.push(node->right);
15.        }
16.    }
17.    return true;
18. }

{{ select(4) }}

  • 该代码用于判断一棵树是否为满二叉树
  • 该代码用于判断一棵树是否为完全二叉树
  • 该代码用于判断一棵树是否为二叉搜索树
  • 该代码用于计算树的高度

5、5、以下代码实现了二叉排序树的哪种操作？

1. TreeNode* op(TreeNode* root, int val) {
2.     if (root == nullptr) return new TreeNode(val);
3.     if (val < root->val) {
4.         root->left = op(root->left, val);
5.     } else {
6.         root->right = op(root->right, val);
7.     }
8.     return root;
9. }

{{ select(5) }}

  • 查找
  • 插入
  • 删除
  • 遍历

6、6、题 给定字符集 {A, B, C, D} 的出现频率分别为 {5, 1, 6, 2} ，则正确的哈夫曼编码是（ ）。

{{ select(6) }}

  • A: 0, B: 100, C: 11, D: 101
  • A: 11, B: 100, C: 0, D: 101
  • A: 0, B: 101, C: 11, D: 100
  • A: 10, B: 101, C: 0, D: 100

7、7、关于动态规划的描述，正确的是（ ）。

{{ select(7) }}

  • 动态规划算法的时间复杂度总是低于贪心算法。
  • 动态规划要求问题必须具有最优子结构和重叠子问题两个性质。
  • 动态规划通过递归实现时不需要存储中间结果。
  • 动态规划的核心思想是将问题分解为互不重叠的子问题。

8、8、以下代码中，类的构造函数被调用了（ ）次。

1. class MyClass {
2. public:
3.     MyClass() {
4.         cout << "Constructor called!" << endl;
5.     }
6. };
7. int main() {
8.     MyClass obj1;
9.     MyClass obj2 = obj1;
10.    return 0;
11. }

{{ select(8) }}

  • 1
  • 2
  • 3
  • 0

9、9、以下代码实现了循环队列的哪种操作？

1. class CircularQueue {
2.     int* arr;
3.     int front, rear, size;
4. public:
5.     CircularQueue(int k) {
6.         size = k;
7.         arr = new int[k];
8.         front = rear = -1;
9.     }
10.    bool enQueue(int value) {
11.        if (isFull()) return false;
12.        if (isEmpty()) front = 0;
13.        rear = (rear + 1) % size;
14.        arr[rear] = value;
15.        return true;
16.    }
17. };

{{ select(9) }}

  • 入队
  • 出队
  • 查看队首元素
  • 判断队列是否为空

10、10、以下代码实现了二叉树的深度优先搜索（DFS），并统计叶子结点的数量，则横线上应填写（ ）。

#include <iostream>
#include <stack>

// 定义二叉树节点结构体
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

int countLeafNodes(TreeNode* root) {
    if (root == nullptr) return 0;
    std::stack<TreeNode*> s;
    s.push(root);
    int count = 0;
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        if (node->left == nullptr && node->right == nullptr) {
            count++;
        }
        if (node->right) s.push(node->right);
        if (node->left) s.push(node->left);
    }
    return count;
}

{{ select(10) }}

  • if (node->left) s.push(node->left);
  • if (node->left) s.pop(node->left);
  • if (node->left) s.front(node->left);
  • if (node->left) s.push(node->right);

11、11、以下代码实现了二叉树的广度优先搜索（BFS），并查找特定值的节点，则横线上应填写（ ）。

1. TreeNode* findNode(TreeNode* root, int target) {
2.     if (root == nullptr) return nullptr;
3.     queue<TreeNode*> q;
4.     q.push(root);
5.     while (!q.empty()) {
6.         TreeNode* current = q.front();
7.         q.pop();
8.         if (current->val == target) {
9.             return current; // 找到目标节点
10.        }
11.        ———————————————————— // 在此处填入代码
12.    }
13.    return nullptr; // 未找到目标节点
14. }

{{ select(11) }}

12、12、 以下代码用于生成 位格雷编码。横线上应填写（ ）。

1. vector<string> generateGrayCode(int n) {
2.     if (n == 0) return {"0"};
3.     if (n == 1) return {"0", "1"};
4.     vector<string> prev = generateGrayCode(n - 1);
5.     vector<string> result;
6.     for (string s : prev) {
7.         result.push_back("0" + s); // 在前缀添加 0
8.     }
9.     for (int i = prev.size() - 1; i >= 0; i--) {
10.        ———————————————————— // 在此处填入代码
11.    }
12.    return result;
13. }

{{ select(12) }}

  • result.push_back("1" + prev[i]);
  • result.push_back("0" + prev[i]);
  • result.push_back(prev[i] + "1");
  • result.push_back(prev[i] + "0");

13、13、以下代码实现了0/1背包问题的动态规划解法。假设物品重量为 weights[] ，价值为 values[] ，背包容量为 W ，横线上应填写（ ）。

1. int knapsack(int W, vector<int>& weights, vector<int>& values) {
2.     int n = weights.size();
3.     vector<vector<int>> dp(n + 1, vector<int>(W + 1, 0));
4.     for (int i = 1; i <= n; i++) {
5.         for (int j = 1; j <= W; j++) {
6.             if (weights[i - 1] > j) {
7.                 dp[i][j] = dp[i - 1][j]; // 当前物品装不下
8.             } else {
9.                 dp[i][j] = max(_________________________); // 在此处填入代码
10.            }
11.        }
12.    }
13.    return dp[n][W];
14. }

{{ select(13) }}

  • dp[i-1][j], values[i-1]
  • dp[i-1][j], dp[i-1][j - weights[i-1]] + values[i-1]
  • dp[i][j-1], values[i-1]
  • dp[i-1][j - weights[i-1]] + values[i-1], dp[i][j-1]

14、14、以下代码用于检查字符串中的括号是否匹配，横线上应填写（ ）。

1. bool isBalanced(string s) {
2.     stack<char> st;
3.     for (char c : s) {
4.         if (c == '(' || c == '[' || c == '{') {
5.             st.push(c);
6.         } else {
7.             if (st.empty()) return false; // 无左括号匹配
8.             char top = st.top();
9.             st.pop();
10.            if ((c == ')' && top != '(') ||
11.                (c == ']' && top != '[') ||
12.                (c == '}' && top != '{')) {
13.                return false;
14.            }
15.        }
16.    }
17.    return ________________; //在此处填入代码
18. }

{{ select(14) }}

  • true
  • false
  • st.empty()
  • !st.empty()

15、15、关于下面代码，说法错误的是（ ）。

1. class Shape {
2. protected:
3.     string name;
4. public:
5.     Shape(const string& n) : name(n) {}
6.     virtual double area() const {
7.         return 0.0;
8.     }
9. };
10. class Circle : public Shape {
11. private:
13.     double radius; 
14. public:
15.     Circle(const string& n, double r) : Shape(n), radius(r) {}
16.     double area() const override {
17.         return 3.14159 * radius * radius;
18.     }
19. };
20. class Rectangle : public Shape {
21. private:
22.     double width; // 宽度
23.     double height; // 高度
24. public:
25.     Rectangle(const string& n, double w, double h) : Shape(n), width(w), height(h) {}
26.     double area() const override {
27.         return width * height;
28.     }
29. };
30. int main() {
31.     Circle circle("MyCircle", 5.0);
32.     Rectangle rectangle("MyRectangle", 4.0, 6.0);
33.     Shape* shapePtr = &circle;
34.     cout << "Area: " << shapePtr->area() << endl;
35.     shapePtr = &rectangle;
36.     cout << "Area: " << shapePtr->area() << endl;
37.     return 0;
38. }

{{ select(15) }}

  • 语句 Shape* shapePtr = &circle; 和 shapePtr = &rectangle; 出现编译错误
  • Shape 为基类， Circle 和 Rectangle 是派生类
  • 通过继承， Circle 和 Rectangle 复用了 Shape 的属性和方法，并扩展了新的功能
  • Circle 和 Rectangle 通过重写（override）基类的虚函数 area 和基类指针，实现了运行时多态

二、判断题（每题 22 分，共 2020 分）

16、16、哈夫曼树在构造过程中，每次合并权值最小的两个节点，最终生成的树带权路径长度最小。

{{ select(16) }}

  • 正确
  • 错误

17、17、格雷编码的相邻两个编码之间必须有多位不同，以避免数据传输错误。

{{ select(17) }}

  • 正确
  • 错误

18、18、在树的深度优先搜索（DFS）中，使用队列作为辅助数据结构以实现“先进后出”的访问顺序。

{{ select(18) }}

  • 正确
  • 错误

19、19、题 以下代码实现的是二叉树的中序遍历：

1. void traverse(TreeNode* root) {
2.     if (root == nullptr) return;
3.     traverse(root->left);
4.     cout << root->val << " ";
5.     traverse(root->right);
6. }

{{ select(19) }}

  • 正确
  • 错误

20、20、C++ 支持构造函数重载，但默认无参数的构造函数只能有一个。

{{ select(20) }}

  • 正确
  • 错误

21、21、二叉排序树（BST）中，若某节点的左子树为空，则该节点一定是树中的最小值节点。

{{ select(21) }}

  • 正确
  • 错误

22、22、在动态规划解决一维硬币找零问题时，若硬币面额为 [1, 3, 4] ，目标金额为 6 ，则最少需要 2 枚硬币（3+3）。

{{ select(22) }}

  • 正确
  • 错误

23、23、面向对象编程中，封装是指将数据和行为绑定在一起，并对外隐藏实现细节。

{{ select(23) }}

  • 正确
  • 错误

24、24、题 以下代码创建的树是一棵完全二叉树：

1. TreeNode* root = new TreeNode{1};
2. root->left = new TreeNode{2};
3. root->right = new TreeNode{3};
4. root->left->left = new TreeNode{4};

{{ select(24) }}

  • 正确
  • 错误

25、25、栈和队列均可以用双向链表实现，插入和删除操作的时间复杂度为 O(1) 。

{{ select(25) }}

  • 正确
  • 错误
  1. 关于
  2. 联系我们
  3. 隐私
  4. 服务条款
  5. 版权申诉
  6. Language
  7. 兼容模式
  8. 主题
  3. Worker 0, 24ms
  4. Powered by Hydro v4.15.0 Community