1. $\$ C++ 中构造函数可以声明为虚函数，从而实现运行时多态。

{{ select(1) }}

• 正确
• 错误

2. $\$ 通过指向 Base 的指针删除 Derived 对象时，一定会先调用 Derived 的析构函数，再调用 Base 的析构函数。

#include <iostream>
using namespace std;
class Base {
public:
    ~Base() {
        cout << "Base destructor" << endl;
    }
};
class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived destructor" << endl;
    }
};
int main() {
    Base* p = new Derived();
    delete p;
    return 0;
}

{{ select(2) }}

• 正确
• 错误

3. $\$ 在 C++ STL 中，stack 的 pop() 函数会返回栈顶元素并将其删除。

{{ select(3) }}

• 正确
• 错误

4. $\$ 程序运行后会输出 $2$。

int main() {
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.pop();
    cout << q.front() << endl;
    return 0;
}

{{ select(4) }}

• 正确
• 错误

5. $\$ 下列函数试图将整数 x 插入到一棵二叉搜索树中。假设二叉搜索树满足如下性质：对于任意结点，左子树中所有结点的值均小于该结点的值，右子树中所有结点的值均大于或等于该结点的值。判断该函数是否能够在插入后保持二叉搜索树性质。

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* insertNode(TreeNode* root, int x) {
    if (root == nullptr) {
        return new TreeNode(x);
    }
    if (x < root->val) {
        root->right = insertNode(root->right, x);
    } else {
        root->left = insertNode(root->left, x);
    }
    return root;
}

{{ select(5) }}

• 正确
• 错误

6. $\$ 哈夫曼编码一定唯一，只要字符频率相同，得到的编码也一定完全相同。

{{ select(6) }}

• 正确
• 错误

7. $\$ 若用数组按层序存储完全二叉树，且根节点下标为 $0$，则下标为 $i$ 的节点左孩子下标为 $2\times i+1$，右孩子下标为 $2\times i+2$。

{{ select(7) }}

• 正确
• 错误

8. $\$ 以下代码可以正确地按层换行输出二叉树的节点值。

void printByLevel(TreeNode* root) {
    if (!root) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        for (int i = 0; i < q.size(); ++i) {
            TreeNode* cur = q.front();
            q.pop();
            cout << cur->val << " ";
            if (cur->left) q.push(cur->left);
            if (cur->right) q.push(cur->right);
        }
        cout << endl;
    }
}

{{ select(8) }}

• 正确
• 错误

9. $\$ 使用栈非递归实现二叉树前序遍历时，若希望先访问左子树，通常应先将右孩子入栈，再将左孩子入栈。

{{ select(9) }}

• 正确
• 错误

10. $\$ 动态规划问题通常要求具有最优子结构，并且常常存在重叠子问题。

{{ select(10) }}

• 正确
• 错误