客观题逐题精讲

#include <iostream>
using namespace std;

class my_class {
    public:
        static int count;
        my_class() {
            count++;
        }
        ~my_class() {
            count--;
        }
        static void print_count() {
            cout << count << "";
        }
    };
    int my_class::count = 0;
    int main() {
        my_class obj1;
        my_class::print_count();
        my_class obj2;
        obj2.print_count();
        my_class obj3;
        obj3.print_count();
        return 0;
    }

#include <iostream>
using namespace std;

class shape {
    protected:
        int width, height;
    public:
        shape(int a = 0, int b = 0) {
            width = a;
            height = b;
        }
        virtual int area() {
            cout << "parent class area: " << endl;
            return 0;
        }
    };

class rectangle: public shape {
public:
    rectangle(int a = 0, int b = 0) : shape(a, b) { }
    int area() {
        cout << "rectangle area: " ;
        return (width * height);
    }
};

class triangle: public shape {
public:
    triangle(int a = 0, int b = 0) : shape(a, b) { }
    int area() {
        cout << "triangle area: " ;
        return (width * height / 2);
    }
};

int main() {
    shape *pshape;
    rectangle rec(10, 7);
    triangle tri(10, 5);

    pshape = &rec;
    pshape->area();

    pshape = &tri;
    pshape->area();
    return 0;
}

#include <iostream>
using namespace std;

stack<int> ten2bin(int n) {
    stack<int> st;
    int r, m;
    r = n % 2;
    m = n / 2;
    st.push(r);
    while (m != 1) {
        r = m % 2;
        st.push(r);
        m = m / 2;
    }
    st.push(m);
    return st;
}

int main() {
    int n;
    cin >> n;
    stack<int> bin;
    bin = ten2bin(n);
    while (!bin.empty()) {
        ___ // 在此处填入代码
    }
    return 0;
}

#include <iostream>

using namespace std;

class circular_queue {
    private:
        int *arr; // 数组用于存储队列元素
        int capacity; // 队列容量
        int front; // 队头指针
        int rear; // 队尾指针

    public:
        circular_queue(int size) {
            capacity = size + 1; // 为了避免队列满时与队列空时指针相等的情况，多预留一个空间
            arr = new int[capacity];
            front = 0;
            rear = 0;
        }

        ~circular_queue() {
            delete[] arr;
        }

        bool is_empty() {
            return front == rear;
        }

        bool is_full() {
            // 在此处填入代码
        }

        int en_queue(int data) {
            if (is_full()) {
                cout << "队列已满，无法入队！" << endl;
                return -1;
            }
            arr[rear] = data;
            rear = (rear + 1) % capacity;
            return 1;
        }

        int de_queue() {
            if (is_empty()) {
                cout << "队列为空，无法出队！" << endl;
                return -1; // 出队失败，返回一个特殊值
            }
            int data = arr[front];
            front = (front + 1) % capacity;
            return data;
        }
};

int jump_recur(int n) {
    if (n == 1) return 1;
    if (n == 2) return 2;
    return jump_recur(n - 1) + jump_recur(n - 2);
}

int jump_dp(int n) {
    vector<int> dp(n + 1); // 创建一个动态规划数组，用于保存已计算的值
    // 初始化前两个数
    dp[1] = 1;
    dp[2] = 2;
    // 从第三个数开始计算斐波那契数列
    for (int i = 3; i <= n; ++i) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
}

#include <iostream>
#include <queue>

using namespace std;

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

// 宽度优先搜索（BFS）迭代实现
TreeNode* bfs(TreeNode* root, int a) {
    if (root == nullptr) return nullptr;

    queue<TreeNode*> q;
    q.push(root);

    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();

        if (node->val == a)
            return node;
        cout << node->val << " "; // 访问当前节点
        if (node->left) q.push(node->left); // 将左子节点入队
        if (node->right) q.push(node->right); // 将右子节点入队
    }

    return nullptr;
}

#include <iostream>
#include <stack>

using namespace std;

TreeNode* dfs(TreeNode* root, int a) {
    if (root == nullptr) return nullptr;

    stack<TreeNode*> stk;
    stk.push(root);

    while (!stk.empty()) {
        TreeNode* node = stk.top();
        stk.pop();
        if (node->val == a)
            return node;
        cout << node->val << " "; // 访问当前节点
        if (node->right) stk.push(node->right); // 先压入右子节点
        if (node->left) stk.push(node->left); // 再压入左子节点
    }

    return nullptr;
}