АВЛ-деревья C++. Циклично добавлять элементы в дерево, пока высота всех листов дерева не будет одинакова

Недавно начал изучать структуры и алгоритмы обработки данных, и в качестве задания нужно написать свое дерево и обойти его в ширину, найти максимальную глубину листа и циклично добавлять элементы в дерево, пока высота всех листов дерева не будет одинакова, но не превысит изначально найденного максимального значения. Справился со всем, кроме последнего пункта задания

#include <iostream>
#include <iomanip>
#include <locale>
using namespace std;

struct TreeNode
{
    int data;
    int depth;
    TreeNode* left,
        * right;
};

struct QueueNode
{
    TreeNode* trans;
    QueueNode* next;
};

class Queue
{
private:
    QueueNode* Head;

public:
    Queue()
    {
        Head = NULL;
    }

    int isEmpty()
    {
        if (Head == NULL)
            return 1;
        else
            return 0;
    }

    void addToQueue(TreeNode* tmp)
    {
        QueueNode* Ptr = new QueueNode;
        Ptr->trans = tmp;

        if (Head == NULL)
        {
            Head = Ptr;
            Ptr->next = NULL;
        }
        else
        {
            QueueNode* tmp_c = Head;

            while (tmp_c->next != NULL)
                tmp_c = tmp_c->next;

            tmp_c->next = Ptr;
            Ptr->next = NULL;
        }
    }

    TreeNode* delQueue()
    {
        QueueNode* cur = Head->next;
        TreeNode* tmp_c = Head->trans;

        if (Head != NULL)
        {
            delete Head;
            Head = cur;
            return tmp_c;
        }
        else
            return NULL;
    }
};

class Tree
{
private:
    TreeNode* root, * next;

public:
    Tree()
    {
        root = NULL;
    }

    void levelOrder()                   //обход в ширину
    {
        Queue Universal;
        Universal.addToQueue(root);

        TreeNode* tmp;

        while (!Universal.isEmpty())
        {
            tmp = Universal.delQueue();
            cout << tmp->data << " ";

            if (tmp->left != NULL)
                Universal.addToQueue(tmp->left);
            if (tmp->right != NULL)
                Universal.addToQueue(tmp->right);
        }
    }

    void addToTreeHelper(int value)
    {
        addToTree(&root, value);
    }

    void addToTree(TreeNode** Ptr, int value)
    {
        if ((*Ptr) == NULL)
        {
            (*Ptr) = new TreeNode;
            (*Ptr)->data = value;
            (*Ptr)->left = (*Ptr)->right = NULL;
        }
        else
        {
            if (value < (*Ptr)->data)
                addToTree(&(*Ptr)->left, value);
            else if (value > (*Ptr)->data)
                addToTree(&(*Ptr)->right, value);
            else
                cout << "Дубликат!\n";
        }
    }

    void deleteTreeHelp(int value)
    {
        deleteTree(root, value);
    }

    void deleteTree(TreeNode* Ptr, int value)
    {
        TreeNode* parent = NULL;
        TreeNode* removed = NULL;

        while (Ptr != NULL && Ptr->data != value)
        {
            parent = Ptr;
            if (Ptr->data > value)
                Ptr = Ptr->left;
            else
                Ptr = Ptr->right;
        }

//        int peremen = Ptr->data;

        if (root != NULL)
        {
            TreeNode* child = NULL;
            if (Ptr->left == NULL || Ptr->right == NULL)
            {
                /*случай когда один ребенок*/
                if (Ptr->left == NULL)
                    child = Ptr->right;
                else
                    child = Ptr->left;

                /*если удаляем корень с одним потомком*/
                if (root->data == value)
                    root = child;
                else
                {
                    if (parent->left == Ptr)
                        parent->left = child;
                    else
                        parent->right = child;
                }

                removed = Ptr;
            }
            else            /*if(Ptr -> left != NULL || Ptr -> right != NULL)*/
            {
                /*случай когда 2 ребенка*/
                TreeNode* mostLeft = Ptr->right;

                if (mostLeft->left == NULL)
                {
                    parent = mostLeft;
                }

                while (mostLeft->left != NULL)
                {
                    parent = mostLeft;
                    mostLeft = mostLeft->left;
                }

                if (root->data == value) {
                    removed = mostLeft;

                    if (parent->left == mostLeft)
                        parent->left = NULL;
                    else
                        root->right = mostLeft->right;
                        parent->left = mostLeft->right;
                        parent = NULL;

                    root->data = mostLeft->data;
                }
                else {
                    removed = mostLeft;
                    if (mostLeft->right != NULL && mostLeft->right->data < parent->data)
                    {
                        parent->left = mostLeft->right;
                    }
                    else if(mostLeft->right != NULL)
                    {
                        Ptr->right = parent->right;
                        parent = NULL;
                    }
                    else if (parent->left != NULL)
                    {
                        parent->left = NULL;
                    }
                    else
                    {
                        parent = NULL;
                        Ptr->right = NULL;
                    }

                    Ptr->data = mostLeft->data;
                }
            }
        }
        delete removed;
    }

    void outputHelper(int totalSpace)
    {
        outputTree(root, totalSpace);
    }

    void outputTree(TreeNode* Ptr, int totalSpace)
    {
        while (Ptr != NULL)
        {
            outputTree(Ptr->right, totalSpace + 5);

            for (int i = 1; i <= totalSpace; i++)
                cout << " ";

            cout << Ptr->data << "\n";

            Ptr = Ptr->left;
            totalSpace += 5;
        }
    }
    void maxDepthHelper()
    {
        cout<<"Максимальная глубина дерева: "<<maxDepth(root)<<"\n";
    }
    int maxDepth(TreeNode* T)
    {
        if (T==NULL) return 0;
        return max(maxDepth(T->left),maxDepth(T->right))+1;
    }
    void BalanceTree()
    {
    //TODO: Циклично добавлять элементы в дерево, пока высота всех листов дерева не будет одинакова
    }
};

void instructions();
void menu();

int main()
{
//    wcout.imbue(locale(".866"));
//    wcin.imbue(locale(".866"));

    menu();

    cout << "\n\n";
    return 0;
}

void instructions()
{
    cout << "Выберите пункт меню: " <<
        "\n1 - Добавить элемент" <<
        "\n2 - Удалить элемент" <<
        "\n3 - Вывод дерева" <<
        "\n4 - Поиск максимальной глубины дерева" <<
        "\n5 - Балансировка листьев дерева" <<
        "\n6 - Выход.\n";
}

void menu()
{
    srand (time(NULL));
    Tree Universal;
    int punkt_menu, value, space = 0;

    instructions();
    do {
        cout << "\n? ";
        cin >> punkt_menu;

        switch (punkt_menu)
        {
            case 1:
                cout << "Введите число: ";
                cin >> value;
                for (int i = 0; i < value; i++)
                {
                    Universal.addToTreeHelper(rand() % 100);
                }
//                Universal.addToTreeHelper(value);
                Universal.levelOrder();
                break;
            case 2:
                cout << "Введите значение удаляемого элемента: ";
                cin >> value;

                Universal.deleteTreeHelp(value);
                Universal.levelOrder();
            case 3:
                cout << "Вывод дерева:\n\n";
                Universal.outputHelper(space);
                break;
            case 4:
                Universal.maxDepthHelper();
                break;
            case 5:
                Universal.BalanceTree();
                break;
        }

    } while (punkt_menu != 6);
}