m_tree

#include <bits/stdc++.h>

using namespace std;

struct TreeNode{

    long long int bro;
    long long int left_son;
    long long int parent;
    long long int val;

    TreeNode(long long int val, long long int parent=-1) {
        this->val = val;
        this->parent = parent;
        bro = -1;
        left_son = -1;
    }

};

struct Tree{

    Tree(string name) : tree_name(name) {}

    void insert(long long int val) {
        if (tree_nodes.empty())
            insert(-1, -1, val);
        else
            insert(0, -1, val);
    }

    void equal_tree(Tree& b) {
        for (long long int i = 0; i < tree_nodes.size(); ++i) {
            if (!b.contains(tree_nodes[i]->val))
                delete_node(i);
        }
    }

    bool contains(long long int val) {
        if (tree_nodes.empty())
            return false;
        return contains(0, val);
    }

    void sym_print() {
        if (tree_nodes.empty())
            cout << tree_name << " tree is empty!";
        else {
            cout << tree_name << " tree: ";
            sym_print(0);
        }
        cout << endl;
    }

    void str_print() {
        if (tree_nodes.empty())
            cout << tree_name << " tree is empty!";
        else {
            cout << tree_name << " tree: ";
            str_print(0);
        }
        cout << endl;
    }

private:

    void delete_node(long long int index) {
        if (index == -1)
            return;
        long long int l = left_son(index), r = right_son(index);
        if (l == -1 && r == -1) {
            if (tree_nodes[index]->parent != -1) {
                if (is_right(tree_nodes[index]->parent, tree_nodes[index]->val)) {
                    if (tree_nodes[tree_nodes[index]->parent]->left_son != -1)
                        tree_nodes[tree_nodes[tree_nodes[index]->parent]->left_son]->bro = -1;
                } else
                    tree_nodes[tree_nodes[index]->parent]->left_son = -1;
            }
            deleting_node(index);
        } else if (r == -1) {
            tree_nodes[l]->parent = tree_nodes[index]->parent;
            tree_nodes[l]->bro = tree_nodes[index]->bro;
            if (tree_nodes[index]->parent != -1) {
                if (is_right(tree_nodes[index]->parent, tree_nodes[index]->val)) {
                    if (tree_nodes[tree_nodes[index]->parent]->left_son != -1)
                        tree_nodes[tree_nodes[tree_nodes[index]->parent]->left_son]->bro = l;
                } else {
                    tree_nodes[tree_nodes[index]->parent]->left_son = l;
                }
            }
            deleting_node(index);
        } else if (l == -1) {
            tree_nodes[r]->parent = tree_nodes[index]->parent;
            tree_nodes[r]->bro = tree_nodes[index]->bro;
            if (tree_nodes[index]->parent != -1) {
                if (is_right(tree_nodes[index]->parent, tree_nodes[index]->val)) {
                    if (tree_nodes[tree_nodes[index]->parent]->left_son != -1)
                        tree_nodes[tree_nodes[tree_nodes[index]->parent]->left_son]->bro = r;
                } else {
                    tree_nodes[tree_nodes[index]->parent]->left_son = r;
                }
            }
            deleting_node(index);
        } else {
            tree_nodes[index]->val = del_left(right_son(index));
        }
    }

    long long int del_left(long long index) {
        while (tree_nodes[index]->left_son != -1)
            index = tree_nodes[index]->left_son;
        long long int tmp = tree_nodes[index]->val, r = right_son(index);
        if (r != -1) {
            tree_nodes[r]->parent = tree_nodes[index]->parent;
            if (!is_right(tree_nodes[index]->parent, tree_nodes[index]->val)) {
                tree_nodes[tree_nodes[index]->parent]->left_son = r;
            } else {
                long long int l = left_son(tree_nodes[index]->parent);
                if (l != -1)
                    tree_nodes[l]->bro = r;
            }
        } else {
            if (!is_right(tree_nodes[index]->parent, tree_nodes[index]->val)) {
                tree_nodes[tree_nodes[index]->parent]->left_son = -1;
            } else {
                long long int l = left_son(tree_nodes[index]->parent);
                if (l != -1)
                    tree_nodes[l]->bro = -1;
            }
        }
        deleting_node(index);
        return tmp;
    }

    void deleting_node(long long int index) {
        tree_nodes.erase(tree_nodes.begin() + index);
        for (auto& x : tree_nodes) {
            if (x->parent > index)
                --x->parent;
            if (x->left_son > index)
                --x->left_son;
            if (x->bro > index)
                --x->bro;
        }
    }

    void sym_print(long long int index) {
        if (index == -1)
            return;
        sym_print(left_son(index));
        cout << tree_nodes[index]->val << ' ';
        sym_print(right_son(index));
    }

    void str_print(long long int index) {
        if (index == -1)
            return;
        cout << tree_nodes[index]->val << ' ';
        str_print(left_son(index));
        str_print(right_son(index));
    }

    void insert(long long int index, long long int parent, long long int val) {
        if (index == -1) {
            tree_nodes.push_back(new TreeNode(val, parent));
            check_node(tree_nodes.size() - 1);
            return;
        }
        if (val > tree_nodes[index]->val) {
            insert(right_son(index), index, val);
        } else {
            insert(left_son(index), index, val);
        }
    }

    bool contains(long long int index, long long int val) {
        if (index == -1)
            return false;
        if (val == tree_nodes[index]->val)
            return true;
        if (tree_nodes[index]->val < val) {
            return contains(right_son(index), val);
        }
        return contains(left_son(index), val);
    }

    void check_node(long long int index) {
        long long int parent = tree_nodes[index]->parent;
        if (parent != -1)
            if (is_right(parent, tree_nodes[index]->val)) {
                if (tree_nodes[parent]->left_son != -1)
                    tree_nodes[tree_nodes[parent]->left_son]->bro = index;
            } else {
                tree_nodes[parent]->left_son = index;
                for (long long int i = parent + 1; i < tree_nodes.size(); ++i) {
                    if (i == index)
                        continue;
                    if (tree_nodes[i]->parent == parent) {
                        tree_nodes[index]->bro = i;
                        break;
                    }
                }
            }
    }

    long long int left_son(long long int index) {
        return tree_nodes[index]->left_son;
    }

    long long int right_son(long long int index) {
        if (tree_nodes[index]->left_son != -1)
            return tree_nodes[tree_nodes[index]->left_son]->bro;
        for (long long int i = index + 1; i < tree_nodes.size(); ++i) {
            if (tree_nodes[i]->parent == index)
                return i;
        }
        return -1;
    }

    bool is_right(long long int parent_index, long long int val) {
        return tree_nodes[parent_index]->val < val;
    }

    string tree_name;
    vector<TreeNode*> tree_nodes;
};

int main() {
    int a;
    Tree A("A"), B("B");
    cout << "Enter count of elements in A tree: ";
    cin >> a;
    for (int i = 0; i < a; ++i) {
        int t;
        cout << "Enter " << i + 1 << " element: ";
        cin >> t;
        A.insert(t);
    }
    A.str_print();
    cout << "Enter count of elements in B tree: ";
    cin >> a;
    for (int i = 0; i < a; ++i) {
        int t;
        cout << "Enter " << i + 1 << " element: ";
        cin >> t;
        B.insert(t);
    }
    B.sym_print();
    A.equal_tree(B);
    cout << "After operation:\n";
    A.str_print();
}