5621：[GESP202609六级] 客观题
文件提交：无需freopen
内存限制：128 MB
时间限制：1.000 S
评测方式：文本裁判
金币值：
命题人：
提交：0
解决：0
题目描述
## 一、单选题（每题 2 分，共 30 分）
**第 1 题** 下列代码执行后的输出结果是（ ）
```cpp
01 class Animal {
02 public:
03 virtual void speak() {
04 cout << "Animal ";
05 }
06 virtual ~Animal() = default;
07 };
08
09 class Cat : public Animal {
10 public:
11 void speak() override {
12 cout << "Cat ";
13 }
14 };
15
16 int main() {
17 Animal *p = new Cat();
18 p->speak();
19 delete p;
20 return 0;
21 }
```
- `Animal`
- `Cat`
- `Animal Cat`
- 编译错误
**第 2 题** 下列代码中，横线处应填写（ ），才能正确调用基类的带参数构造函数。
```cpp
01 class Machine {
02 protected:
03 string id;
04
05 public:
06 Machine(string s) : id(s) {}
07 };
08
09 class Robot : public Machine {
10 int level;
11
12 public:
13 Robot(string s, int n) : __________, level(n) {}
14 };
```
- `Machine(s)`
- `Machine::id(s)`
- `super(s)`
- `id(s)`
**第 3 题** 下列代码执行后的输出顺序是（ ）
```cpp
01 class Base {
02 public:
03 Base() {
04 cout << "B ";
05 }
06 virtual ~Base() {
07 cout << "~B ";
08 }
09 };
10
11 class Derived : public Base {
12 public:
13 Derived() {
14 cout << "D ";
15 }
16 ~Derived() {
17 cout << "~D ";
18 }
19 };
20
21 int main() {
22 Base *p = new Derived();
23 delete p;
24 return 0;
25 }
```
- `B D ~B ~D`
- `D B ~D ~B`
- `B D ~D ~B`
- `B D ~B`
**第 4 题** 下列代码执行后的输出结果是（ ）
```cpp
01 stack s;
02 queue q;
03 for (int i = 2; i <= 6; i += 2) {
04 s.push(i);
05 q.push(i);
06 }
07 s.pop();
08 q.pop();
09 cout << s.top() << " " << q.front();
```
- `2 4`
- `4 4`
- `4 6`
- `6 2`
**第 5 题** 下面循环队列采用“空出一个位置”的方式区分队空和队满。横线处应填写（ ）
```cpp
01 const int MAXN = 8;
02 int data[MAXN];
03 int front = 0, rear = 0;
04
05 bool full() {
06 return __________________________;
07 }
```
- `rear == front`
- `(front + 1) % MAXN == rear`
- `(rear + 1) % MAXN == front`
- `rear == MAXN - 1`
**第 6 题** 下列函数实现了二叉树的哪种遍历方式（ ）
```cpp
01 void visit(TreeNode *root) {
02 if (root == nullptr)
03 return;
04 visit(root->left);
05 cout << root->val << " ";
06 visit(root->right);
07 }
```
- 前序遍历
- 中序遍历
- 后序遍历
- 层序遍历
**第 7 题** 已知一棵二叉树的先序遍历序列为 `A B D E C F`，中序遍历序列为 `D B E A C F`，则其后序遍历序列是（ ）
- `D E B F C A`
- `D B E F C A`
- `E D B F C A`
- `D E B C F A`
**第 8 题** 下面函数用于计算二叉树的高度，横线处应填写（ ）
```cpp
01 int height(TreeNode *root) {
02 if (root == nullptr)
03 return 0;
04 int leftH = height(root->left);
05 int rightH = height(root->right);
06 return __________________________;
07 }
```
- `leftH + rightH`
- `min(leftH, rightH) + 1`
- `max(leftH, rightH)`
- `max(leftH, rightH) + 1`
**第 9 题** 以下代码实现二叉树左子树优先的深度优先搜索算法，则横线上应填写（ ）
```cpp
01 void dfs(TreeNode *root) {
02 if (root == nullptr)
03 return;
04
05 stack s;
06 s.push(root);
07 while (!s.empty()) {
08 TreeNode *node = s.top();
09 s.pop();
10 cout << node->value << " ";
11
12 ------------------------ // 在此处填入代码
13 }
14 }
```
- ```cpp
01 s.push(node->right);
02 s.push(node->left);
```
- ```cpp
01 s.push(node->left);
02 s.push(node->right);
```
- ```cpp
01 if (node->right)
02 s.push(node->right);
03 if (node->left)
04 s.push(node->left);
```
- ```cpp
01 if (node->left)
02 s.push(node->left);
03 if (node->right)
04 s.push(node->right);
```
**第 10 题** 下面函数在二叉搜索树中查找值 `x`。横线处应填写（ ）
```cpp
01 TreeNode *searchBST(TreeNode *root, int x) {
02 if (root == nullptr || root->val == x)
03 return root;
04 if (x < root->val)
05 return searchBST(root->left, x);
06 return __________________________;
07 }
```
- `searchBST(root->left, x)`
- `searchBST(root->right, x)`
- `searchBST(root, x + 1)`
- `root->right`
**第 11 题** 有 $5$ 个字符，其出现频率分别为 $2$、$4$、$5$、$9$、$12$。按哈夫曼算法构造编码树，其最小带权路径长度 $WPL$ 为（ ）
- $68$
- $69$
- $71$
- $73$
**第 12 题** 下面代码用反射法生成 $n$ 位格雷编码，横线处应填写（ ）
```cpp
01 vector gray(int n) {
02 vector ans = {"0", "1"};
03 for (int bit = 2; bit <= n; ++bit) {
04 int oldSize = ans.size();
05 for (int i = oldSize - 1; i >= 0; --i)
06 ans.push_back(__________________________);
07 for (int i = 0; i < oldSize; ++i)
08 ans[i] = "0" + ans[i];
09 }
10 return ans;
11 }
```
- `ans[i] + "1"`
- `"0" + ans[i]`
- `"1" + ans[i]`
- `ans[oldSize - i - 1]`
**第 13 题** 下面代码计算走到第 $n$ 级台阶的方法数，每次可以走 $1$ 级或 $2$ 级。横线处应填写（ ）
```cpp
01 int ways(int n) {
02 if (n <= 2)
03 return n;
04 vector dp(n + 1);
05 dp[1] = 1;
06 dp[2] = 2;
07 for (int i = 3; i <= n; ++i)
08 dp[i] = __________________________;
09 return dp[n];
10 }
```
- `dp[i - 1] + 1`
- `dp[i - 1] + dp[i - 2]`
- `dp[i - 2] + 2`
- `2 * dp[i - 1]`
**第 14 题** 下面代码求从包含非负元素的数组中选择若干个互不相邻元素所能得到的最大和。横线处应填写（ ）
```cpp
01 int maxSum(vector &a) {
02 int n = a.size();
03 if (n == 0)
04 return 0;
05 if (n == 1)
06 return a[0];
07 vector dp(n);
08 dp[0] = a[0];
09 dp[1] = max(a[0], a[1]);
10 for (int i = 2; i < n; ++i)
11 dp[i] = __________________________;
12 return dp[n - 1];
13 }
```
- `dp[i - 1] + a[i]`
- `dp[i - 2] + a[i]`
- `max(dp[i - 1], dp[i - 2] + a[i])`
- `max(dp[i - 1], a[i])`
**第 15 题** 下面是一维数组实现的 `0/1` 背包。内层循环必须从大到小枚举容量，主要原因是（ ）
```cpp
01 for (int i = 0; i < n; ++i) {
02 for (int w = W; w >= weight[i]; --w) {
03 dp[w] = max(dp[w], dp[w - weight[i]] + value[i]);
04 }
05 }
```
- 保证每件物品最多被选择一次
- 保证物品必须按照重量从大到小选择
- 降低时间复杂度到 $O(n)$
- 防止数组 $dp$ 发生越界
## 二、判断题（每题 2 分，共 20 分）
**第 1 题** 下列代码可以正常编译，因为编译器会自动为 `Student` 类生成一个无参数构造函数。
```cpp
01 class Student {
02 public:
03 Student(int x) {
04 age = x;
05 }
06
07 private:
08 int age;
09 };
10
11 int main() {
12 Student s;
13 }
```
- 正确
- 错误
**第 2 题** 下列代码合法，因为派生类可以直接访问基类的私有成员 `value`。
```cpp
01 class Base {
02 private:
03 int value = 10;
04 };
05
06 class Child : public Base {
07 public:
08 int get() {
09 return value;
10 }
11 };
```
- 正确
- 错误
**第 3 题** 下列代码执行后，输出结果为 $30$。
```cpp
01 queue q;
02 q.push(10);
03 q.push(20);
04 q.push(30);
05 q.pop();
06 cout << q.front();
```
- 正确
- 错误
**第 4 题** 一棵完全二叉树按照从上到下、从左到右的顺序，将节点依次存储在数组 `tree[1] 、tree[2] 、……`中。若节点 `tree[i]` 存在左孩子，则其左孩子存储在 `tree[2 * i]` 中。
- 正确
- 错误
**第 5 题** 对任意一棵二叉搜索树执行中序遍历，得到的关键字序列一定是非递减的。
```cpp
01 void inorder(TreeNode *root) {
02 if (!root)
03 return;
04 inorder(root->left);
05 cout << root->val << " ";
06 inorder(root->right);
07 }
```
- 正确
- 错误
**第 6 题** 若使用下列代码从节点 `start` 开始访问一棵树，则第一次到达某个节点时所经过的边数，一定是从 `start` 到该节点的最少边数。
```cpp
01 vector tree[100];
02 bool visited[100];
03 int dist[100];
04
05 void search(int start) {
06 queue q;
07 q.push(start);
08 visited[start] = true;
09 dist[start] = 0;
10
11 while (!q.empty()) {
12 int u = q.front();
13 q.pop();
14
15 for (int v : tree[u]) {
16 if (!visited[v]) {
17 visited[v] = true;
18 dist[v] = dist[u] + 1;
19 q.push(v);
20 }
21 }
22 }
23 }
```
- 正确
- 错误
**第 7 题** 哈夫曼编码的生成过程基于贪心算法，出现频率越高的字符，其编码长度一定不会比出现频率更低的字符更长。
- 正确
- 错误
**第 8 题** 在 $n$ 位格雷码中，任意两个编码之间都只相差一个二进制位。
- 正确
- 错误
**第 9 题** 下列一维动态规划代码实现的是完全背包问题，因为在处理第 `i` 种物品时，同一种物品可能被重复选择。
```cpp
01 for (int i = 0; i < n; ++i) {
02 for (int w = weight[i]; w <= W; ++w) {
03 dp[w] = max(dp[w], dp[w - weight[i]] + value[i]);
04 }
05 }
```
- 正确
- 错误
**第 10 题** 下列递归程序能得到正确的斐波那契数，其时间复杂度和空间复杂度都是 $O(n)$。
```cpp
01 int fib(int n) {
02 if (n <= 1)
03 return n;
04 return fib(n - 1) + fib(n - 2);
05 }
```
- 正确
- 错误