Бинарные деревья, удаление элементов

#include <iostream>
#include <iomanip>
#include <ctime>
 
using namespace std;
 
class Tree {
    struct Node {
        Node* left;
        Node* right;
        int data;
        int height;
        Node(int d, Node* l = NULL, Node* r = NULL) {
            data = d;
            left = l;
            right = r;
            height = 1;
        }
    };
 
    Node* head;
    void _insert(int data, Node** node) {
        if (!*node)
            *node = new Node(data);
        else {
            if ((*node)->data > data)
                _insert(data, &(*node)->left);
            else
                _insert(data, &(*node)->right);
            if (balance)
                *node = BalanceTree(*node);
        }
    }
    void _clear(Node* node)
    {
        if (node)
        {
            Node* l = node->left;
            Node* r = node->right;
            delete node;
            _clear(l);
            _clear(r);
        }
    }
 
    void _Print(Node* node, int level = 0)
    {
        if (node)
        {
            if (node->right)
                _Print(node->right, level + 4);
            if (level)
                cout << setw(level) << ' ';
            if (node->right)
                cout << " /\n" << setw(level) << ' ';
            cout << node->data << "\n ";
            if (node->left)
            {
                cout << setw(level) << ' ' << "\\\n";
                _Print(node->left, level + 4);
            }
        }
    }
 
 
 
 
    int Height(Node* node)
    {
        if (node)
            return node->height;
        else
            return 0;
    }
 
 
 
    Node* RotateLeft(Node* node)
    {
        Node* rn = node->right;
        node->right = rn->left;
        rn->left = node;
        FixHeight(node);
        FixHeight(rn);
        return rn;
    }
 
    Node* RotateRight(Node* node)
    {
        Node* rn = node->left;
        node->left = rn->right;
        rn->right = node;
        FixHeight(node);
        FixHeight(rn);
        return rn;
    }
 
    int CalculateBalancefactor(Node* node)
    {
        return Height(node->right) - Height(node->left);
    }
 
    void FixHeight(Node* node)
    {
        int hl = Height(node->left);
        int hr = Height(node->right);
        if (hl > hr)
            node->height = hl + 1;
        else
            node->height = hr + 1;
    }
 
 
 
 
    Node* BalanceTree(Node* node)
    {
        FixHeight(node);
        if (CalculateBalancefactor(node) == 2)
        {
            if (CalculateBalancefactor(node->right) < 0)
                node->right = RotateRight(node->right);
            return RotateLeft(node);
        }
        if (CalculateBalancefactor(node) == -2)
        {
            if (CalculateBalancefactor(node->left) > 0)
                node->left = RotateLeft(node->left);
            return RotateRight(node);
        }
        return node;
    }
 
public:
 
 
    Tree()
    {
        head = NULL;
    }
 
    ~Tree()
    {
        ClearTree();
    }
 
 
 
 
    bool balance = false;
    void InsertData(int data) { _insert(data, &head); }
    void ClearTree() { _clear(head); head = NULL; }
    void PrintTree() { _Print(head); };
};
 
int main()
{
    setlocale(LC_ALL, "rus");
    srand(time(NULL));
    Tree tree;
    int size;
    cout << "Кол-во элементов: ";
    cin >> size;
    int* a = new int[size];
    cout << "Элементы: ";
    for (int i = 0; i < size; ++i)
    {
        int t = rand() % 30;
        tree.InsertData(t);
        cout << t << " ";
        a[i] = t;
    }
    cout << "\nИсходное дерево:\n\n";
    tree.PrintTree();
    tree.ClearTree();
    tree.balance = true;
    for (int i = 0; i < size; ++i)
        tree.InsertData(a[i]);
    cout << "\n\nСбалансированное дерево:\n\n";
    tree.PrintTree();
    return 0;
}