[GESP202506 六级 ] 客观题

ID: 205

Type: Objective

Tried: 0

Accepted: 0

Difficulty: (None)

Uploaded By:

wzy

Tags>

GESP C++编程能力等级认证

单选题

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

{{ select(1) }}

继承
封装
多态
链接

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

Animal(name)
super(name)
Animal::Animal(name)
Animal()

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

{{ select(3) }}

输出 Animal speaks
输出 Dog barks
编译错误
程序崩溃

以下关于栈和队列的代码，执行后输出是（）。

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

{{ select(5) }}

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

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

{{ select(6) }}

完美二叉树
完全二叉树
完满二叉树
平衡二叉树

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

{{ select(7) }}

((i-1)/2)
(i+1)
(i*2)
(2*i+1)

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

{{ select(8) }}

ADFGEHMZ
ADFGHMEZ
AFDGEMZH
AFDHZMEG

设有字符集 ({a, b, c, d, e})，其出现频率分别为 ({5, 8, 12, 15, 20})，得到的哈夫曼编码为（）。

{{ select(9) }}

a: 010  
b: 011  
c: 00  
d: 10  
e: 11

a: 00  
b: 10  
c: 011  
d: 100  
e: 111

a: 10  
b: 01  
c: 011  
d: 100  
e: 111

a: 100  
b: 01  
c: 011  
d: 100  
e: 00

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

{{ select(10) }}

请将下列C++实现的深度优先搜索（DFS）代码补充完整，横线处应填入（）。

{{ select(11) }}

result.push_back(root->val);
dfs(root->left, result);
dfs(root->right, result);

result.push_back(root->left->val);
dfs(root->right, result);
dfs(root->left, result);

result.push_back(root->left->val);
dfs(root->left, result);
dfs(root->right, result);

result.push_back(root->right->val);
dfs(root->right, result);
dfs(root->left, result);

给定一个二叉树，返回每一层中最大的节点值，结果以数组形式返回，横线处应填入（）。

node = q.end();
node = q.front();
```
q.pop();
node = q.front();
```
[ ] D.
```
node = q.front();
q.pop();
```

下面代码实现一个二叉排序树的插入函数（没有相同的数值），横线处应填入（）。

{{ select(13) }}

if (key < root->val)
    insert(root->left, key);
else if (key > root->val)
    insert(root->right, key);

if (key < root->val)
    insert(root->right, key);
else if (key > root->val)
    insert(root->left, key);

insert(root->left, key);
insert(root->right, key);

insert(root->right, key);
insert(root->left, key);

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

{{ select(14) }}

子问题相互独立，不重叠
问题包含重叠子问题和最优子结构
只能从底至顶迭代求解
必须使用递归实现，不能使用迭代

给定n个物品和一个最大承重为W的背包，每个物品有一个重量wt[i]和价值val[i]，每个物品只能选择放或不放。目标是选择若干个物品放入背包，使得总价值最大，且总重量不超过W。关于下面代码，说法正确的是（）。

{{ select(15) }}

该算法不能处理背包容量为0的情况
外层循环遍历背包容量，内层遍历物品
从大到小遍历w是为了避免重复使用同一物品
这段代码计算的是最小重量而非最大价值

判断题

构造函数可以被声明为virtual。

{{ select(16) }}

给定一组字符及其出现的频率，构造出的哈夫曼树是唯一的。

{{ select(17) }}

为了实现一个队列，使其排队操作（pop）的时间复杂度为O(1)并且避免数组删除首元素的O(n)问题，一种常见且有效的方法是使用环形数组，通过调整队首和队尾指针来实现。

{{ select(18) }}

对一棵二叉排序树进行中序遍历，可以得到一个递增的有序序列。

{{ select(19) }}

如果二叉搜索树在连续的插入和删除操作后，所有节点都偏向一侧，导致其退化为类似于链表的结构，这时其查找、插入、删除操作的时间复杂度会从理想情况下的 (O(\log n)) 退化到 (O(n\log n))。

{{ select(20) }}

执行下列代码，my_dog.name 的最终值是 Charlie。

下列 C++ 代码可以成功编译，并且子类 Child 的实例能通过其成员函数访问父类 Parent 的属性 value。

class Parent {
private:
    int value = 100;
};
class Child : public Parent {
public:
    int get_private_val() {
        return value; // 尝试访问父类的私有成员
    }
};

下列代码中的 tree 向量，表示的是一棵完全二叉树（-1 代表空节点）按照层序遍历的结果。
```
#include <vector>
std::vector<int> tree = {1, 2, 3, 4, -1, 6, 7};
```
{{ select(23) }}

在树的深度优先搜索（DFS）中，使用栈作为辅助数据结构以实现“先进后出”的方向顺序。

{{ select(24) }}

下面代码采用动态规划求解零线兑换问题：给定n种硬币，第i种硬币的面值为 (coins[i - 1])，目标金额为 (amt)，每种硬币可以重复选取，求能够凑出目标金额的最少硬币数量；如果不能凑出目标金额，返回 -1。

int coinChangeDPComp(vector<int> &coins, int amt) {
    int n = coins.size();
    int MAX = amt + 1;
    vector<int> dp(amt + 1, MAX);
    dp[0] = 0;
    for (int i = 1; i <= n; i++) {
        for (int a = 1; a <= amt; a++) {
            if (coins[i - 1] > a)
                dp[a] = dp[a];
            else
                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
        }
    }
    return dp[amt] != MAX ? dp[amt] : -1;
}

#G6107. [GESP202506 六级 ] 客观题

单选题

判断题

Status

Development

Support

About