GESP2024年12月认证C++6级真题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() {
        cout << "Constructor called!" << endl;
}
    void display() {
        cout << "Display function called!" << endl;
}
};
int main() {
    MyClass* obj = NULL;
    obj->display();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

void processData() {
    stack<int> s;
    queue<int> q;
    for (int i = 1; i <= 5; ++i) {
        s.push(i);
        q.push(i);
}
    while (!s.empty()) {
        cout << "Stack pop: " << s.top() << endl;
        s.pop();
}
    while (!q.empty()) {
        cout << "Queue pop: " << q.front() << endl;
        q.pop();
}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <iostream>
using namespace std;
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
TreeNode* search(TreeNode* root, int val) {
    cout << root->val << " ";
    if (root == NULL || root->val == val) return root;
if (val < root->val)
        return search(root->left, val);
    else
        return search(root->right, val);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void dfs(TreeNode* root) {
    if (root == nullptr)
        return;
    stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        __________________ // 在此处填入代码
        cout << node->value << " ";
        if (node->right) s.push(node->right);
        if (node->left) s.push(node->left);
}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <queue>
void bfs(TreeNode* root) {
    if (root == NULL) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        ________________// 在此处填入代码
        cout << node->val << " ";
        if (node->left) {
            q.push(node->left);
        }
        if (node->right) {
            q.push(node->right);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

struct TreeNode {
    int value;
    TreeNode* left;
    TreeNode* right;
};
TreeNode* buildCompleteBinaryTree() {
    TreeNode* root = new TreeNode{1};
    root->left = new TreeNode{2};
    root->right = new TreeNode{3};
    root->left->left = new TreeNode{4};
    root->left->right = new TreeNode{5};
    root->right->left = new TreeNode{6};
    return root;
}

1
2
3
4
5
6

void preorder(TreeNode* root) {
    if (root == NULL) return;
    cout << root->val << " ";
    preorder(root->left);
    preorder(root->right);
}