客观题逐题精讲

class Animal {
public:
    std::string name;
    Animal(std::string str) : name(str) {
        std::cout << "Animal created\n";
    }
    virtual void speak() {
        cout << "Animal speaks" << endl;
    }
};

class Dog : public Animal {
    std::string breed;
public:
    Dog(std::string name, std::string b) : _____, breed(b) {
        std::cout << "Dog created\n";
    }
    void speak() override {
        cout << "Dog barks" << endl;
    }
};

int main() {
    Animal* p = new Dog("Rex", "Labrador");
    p->speak();
    delete p;
    return 0;
}

stack<int> s;
queue<int> q;

for (int i = 1; i <= 3; ++i) {
    s.push(i);
    q.push(i);
}
cout << s.top() << " " << q.front() << endl;

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

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};

void dfs(TreeNode* root, vector<int>& result) {
    if (root == nullptr) return;
    _______________________________
}

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);

#include <vector>
#include <queue>
#include <algorithm>

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};

vector<int> largestValues(TreeNode* root) {
    vector<int> result;
    if (!root) return result;

    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int sz = q.size();

        int maxVal = INT_MIN;
        for (int i = 0; i < sz; ++i) {
            TreeNode* node;
            _______________________________
            maxVal = max(maxVal, node->val);
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
        result.push_back(maxVal);
    }
    return result;
}

node = q.end();

node = q.front();

q.pop();
node = q.front();

node = q.front();
q.pop();

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}
};

void insert(TreeNode* &root, int key) {
    if (!root) {
        root = new TreeNode(key);
        return;
    }
    _______________________________
}

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);

int knapsack1D(int W, vector<int>& wt, vector<int>& val, int n) {
    vector<int> dp(W+1, 0);
    for (int i = 0; i < n; ++i) {
        for (int w = W; w >= wt[i]; --w) {
            dp[w] = max(dp[w], dp[w - wt[i]] + val[i]);
        }
    }
    return dp[W];
}

class Dog {
public:
    std::string name;
    Dog(std::string str) : name(str) {}
};

int main() {
    Dog my_dog("Buddy");
    my_dog.name = "Charlie";
    return 0;
}

class Parent {
private:
    int value = 100;
};

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

#include <vector>
std::vector<int> tree = {1, 2, 3, 4, -1, 6, 7};

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;
}