GESP C++ 6级 2024.03
阅读以下广度优先搜索的代码：
void bfs(TreeNode* root) {
if (root == NULL) {
return;
}
queue q;
q.push(root);
while (!q.empty()) {
TreeNode* current = q.front();
q.pop();
cout val left) {
q.push(current->left);
}
if (current->right) {
q.push(current->right);
}
}
}
使用以上算法遍历以下这棵树，可能的输出是（ ）。
1
/ \
2 3
/ \ \
8 9 6
/ \ \
4 5 7
/ \
10 11
1 2 8 9 4 5 3 6 7 10 11
1 2 3 4 5 6 7 8 9 10 11
1 2 3 8 9 6 4 5 7 10 11
1 2 3 8 9 4 5 6 7 10 11
在构建哈夫曼树时，每次应该选择（ ）合并。
最小权值的节点
最大权值的节点
随机节点
深度最深的节点
面向对象的编程思想主要包括以下哪些原则
贪心、动态规划、回溯
并发、并行、异步
递归、循环、分治
封装、继承、多态
在队列中，元素的添加和删除是按照（ ）原则进行的。
先进先出
先进后出
最小值先出
随机进出
给定一个简单的类定义如下，（ ）语句在类的外部正确地创建了一个 Circle 对象并调用了 getArea 函数？
class Circle {
private:
double radius;
public:
Circle(double r) : radius(r) {}
double getArea() {
return 3.14 * radius * radius;
}
};
Circle c = Circle(5.0); c.getArea(c);
Circle c(5.0); getArea(c);
Circle c = new Circle(5.0); c.getArea();
Circle c(5.0); c.getArea();
以下代码希望能在一棵二叉排序树中搜索特定的值，请在横线处填入（ ），使其能正确实现相应功能。
TreeNode* search(TreeNode* root, int target) {
if (root == NULL || root->val == target) {
return root;
}
if (_______________) {
return search(root->left, target);
} else {
return search(root->right, target);
}
}
target left
target val
target > root->val
target > root->left
3 位格雷编码的正确顺序是
000, 001, 010, 011, 100, 101, 110, 111
000, 001, 011, 010, 110, 111, 101, 100
000, 010, 001, 011, 100, 110, 101, 111
000, 010, 110, 100, 111, 101, 011, 001
以下动态规划算法的含义与目的是
int function(vector& nums) {
int n = nums.size();
if (n == 0)
return 0;
if (n == 1)
return nums[0];
vector dp(n, 0);
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for (int i = 2; i < n; ++i) {
dp[i] = max(dp[i - 1], nums[i] + dp[i - 2]);
}
return dp[n - 1];
}
计算数组 nums 中的所有元素的和
计算数组 nums 中相邻元素的最大和
计算数组 nums 中不相邻元素的最大和
计算数组 nums 中的最小元素
给定一个空栈，执行以下操作序列：
操作序列： push(1), push(2), push(3), pop(), pop(), push(4), push(5), pop()
最终栈中的元素是（ ）。
1, 2
1, 4, 5
1, 2, 5
1, 4
一个有 124 个叶子节点的完全二叉树，最多有（ ）个结点。
247
248
249
250