GESP C++ 6级 2025.12

在⾯向对象编程中，下列关于虚函数的描述中，错误的是（ ）。

执⾏如下代码，会输出钢琴：叮咚叮咚和吉他：咚咚当当。这体现了⾯向对象编程的（ ）特性。

class Instrument {
public:
 virtual void play() {
 cout play();
 }

 for (int i = 0; i < 3; ++i) {
 delete instruments[i];
 }
 return 0;
}

关于以下代码，说法正确的是（ ）。

class Instrument {
public:
 void play() {
 cout play(); 
 }

 for (int i = 0; i < 3; ++i) {
 delete instruments[i]; 
 }
 return 0;
}

某⽂本编辑器把⽤户输⼊的字符依次压⼊栈 S。⽤户依次输⼊ A、B、C、D 后，⽤户按了两次撤销（每次撤销，弹出栈顶⼀个字符）。此时栈从栈底到栈顶的内容是：（ ）。

假设循环队列数组长度为 $N$，其中队空判断条件为：front == rear，队满判断条件为：(rear + 1) % N == front，出队对应的操作为：front = (front + 1) % N，⼊队对应的操作为：rear = (rear + 1) % N。循环队列长度 N = 6，初始 front = 1，rear = 1，执⾏操作序列为：⼊队，⼊队，⼊队，出队，⼊队，⼊队，则最终 (front, rear) 的值是（ ）。

以下函数 check() ⽤于判断⼀棵⼆叉树是否为（ ）。

bool check(TreeNode* root) {
 if (!root) return true;

 queue q;
 q.push(root);
 bool hasNull = false;
 while (!q.empty()) {
 TreeNode* cur = q.front(); q.pop();
 if (!cur) {
 hasNull = true;
 } else {
 if (hasNull) return false;
 q.push(cur->left);
 q.push(cur->right);
 }
 }
 return true;
}

以下代码实现了⼆叉树的（ ）。

void traverse(TreeNode* root) {
 if (!root) return;
 traverse(root->left);
 traverse(root->right);
 cout val << " ";
}

下⾯代码实现了哈夫曼编码，则横线处应填写的代码是（ ）。

struct Symbol {
 char ch; // 字符
 long long freq; // 频率
 string code; // 哈夫曼编码
};

struct Node {
 long long w; // 权值
 int l, r; // 左右孩子（节点下标），-1 表示空
 int sym; // 叶子对应符号下标；内部节点为 -1
 Node(long long _w = 0, int _l = -1, int _r = -1, int _sym = -1)
 : w(_w), l(_l), r(_r), sym(_sym) {}
};

// 从 A(leafIdx) 和 B(internalIdx) 的队首取最小的一个节点下标
static int PopMinNode(const vector& nodes,
 const vector& leafIdx, int n, int& pA,
 const vector& internalIdx, int& pB) {
 if (pA = (int)internalIdx.size() ||
 nodes[leafIdx[pA]].w & nodes, Symbol sym[], string& path) {
 if (u == -1) return;

 if (nodes[u].sym != -1) { // 叶子
 sym[nodes[u].sym].code = path;
 return;
 }

 path.push_back('0');
 DFSBuildCodes(nodes[u].l, nodes, sym, path);
 path.pop_back();

 path.push_back('1');
 DFSBuildCodes(nodes[u].r, nodes, sym, path);
 path.pop_back();
}

int BuildHuffmanCodes(Symbol sym[], int n) {
 for (int i = 0; i nodes;
 nodes.reserve(2 * n);

 // 1）建立叶子节点
 vector leafIdx(n);
 for (int i = 0; i internalIdx;
 internalIdx.reserve(n);

 int pA = 0, pB = 0;

 // 3）合并 $n-1$ 次
 for (int k = 1; k < n; k++) {
 int x = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);
 int y = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);

 int z = (int)nodes.size();
 ________________________ // 在此处填写代码 
 }

 int root = internalIdx.back();

 // 4) DFS 生成编码
 string path;
 DFSBuildCodes(root, nodes, sym, path);
 return root; 
}

以下关于哈夫曼编码的说法，正确的是（ ）。

以下函数实现了⼆叉排序树（BST）的（ ）操作。

TreeNode* op(TreeNode* root, int x) {
 if (!root) return new TreeNode(x);
 if (x val)
 root->left = op(root->left, x);
 else
 root->right = op(root->right, x);
 return root;
}