Реализация бинарного поискового дерева в последовательной памяти

#include <iostream>
 
 
struct Tree {   //структура дерева
    int root;
    Tree* left;
    Tree* right;
};
 
 
//функция добавления элемента
 
Tree* add(int value, Tree *tree)
{
    if (tree == NULL) {  // првоерка на пустоту
        tree = new Tree;  //инициализаяция дерева
        tree->root = value;  //т.к. дерево пустое то значение становится корнем
        tree->left = NULL;  //потомков инициализируем пустыми
        tree->right = NULL;
    }
 
    else if (value < tree->root) {  // если значение меньше корня то идем в левого потомка
        tree->left = add(value, tree->left);
    }
 
    else {  // иначе (>=) идем в правого потомка
        tree->right = add(value, tree->right);
    }
    return(tree);
}
 
//вывод дерева прямым обходом
 
void treePrint(Tree *treeP) { 
    if (treeP != NULL) {
        std::cout << treeP->root;  // вначале выводи корень поддерева
        treePrint(treeP->left);  // далее идем в левое поддерева
        treePrint(treeP->right); // далее идем в правое поддерево
    }   
}
 
//функция удаления дерева
 
void treeDelete(Tree *treeD) {
    if (treeD != NULL) {
        treeDelete(treeD->left);
        treeDelete(treeD->right);
        treeD = NULL;
        free(treeD);
    }
}
 
//доступ к узлу
 
 
bool treeContains(int value, Tree *treeC) {
 
 
    if (treeC == NULL) {
        std::cout << "Не найден. Дерево пустое." << std::endl;  // если дерево пустое
        return 0;
    }
 
    if (treeC->root == value) {  // если значение узла равно заданному значению то выводим информацию
        std::cout << "Найден" << std::endl;
        std::cout << treeC->root << std::endl;
        return(true);
    }
 
    else if (value < treeC->root) {  // если значение меньше значения узла, то идем в левое поддерево
        if (treeC->left != NULL) {  // пока есть элемент слева продолжаем поиск, иначе элемента нет в дереве
            treeContains(value, treeC->left); 
        }
        else {
            std::cout << "Не найден" << std::endl;
        }
    } 
    
    else if (value > treeC->root) {  // если значение больше значения узла, то идем в правое поддерево
        if (treeC->right != NULL) {  // пока есть элемент справа продолжаем поиск, иначе элемента нет в дереве
            treeContains(value, treeC->right);
        }
        else {
            std::cout << "Не найден" << std::endl;
        }
    }
}
 
// функция нахождения минимального значения в деревве
 
Tree* minimum(Tree *treeM) {
 
    if (treeM->left == NULL) { // минимальное хначение - это значение находящиеся левее всегов дереве
        return(treeM);        // пока слева есть элементы мы идем налево, как только у поддерева нет левого потомка, возвращаем это поддерево
    }
    return(minimum(treeM->left));
}
 
// функция удаления элемента
 
Tree* removeElement(int value, Tree *treeR) {
    
    if (treeR == NULL) {  // если дерево постое то возвращаем его
        std::cout << "Дерево пустое" << std::endl;
        return(treeR);
    }
 
    if (value < treeR->root) {  // если удаляемый элемент находится в левом поддереве, т.к. он меньше то рекурсивно удаляем его
        treeR->left = removeElement(value, treeR->left);
    }
    else if (value > treeR->root) {  // если удаляемый элемент находится в правом поддереве, т.к. он больше то рекурсивно удаляем его
        treeR->right = removeElement(value, treeR->right);
    }                                                       // тут мы нашли нужный элемент, т.к. он не больше и не меньше удаляемого значения
    else if (treeR->left != NULL && treeR->right != NULL) {  //если у удаляемого узла есть оба потомка, то
        treeR->root = minimum(treeR->right)->root; // мы находим минимальное значение в правом поддереве и записываем его на место удаляемого
        treeR->right = removeElement(treeR->root, treeR->right); // и рекурсивно удаляем этот элемент
    }
    else { // иначе у узла есть один потомок
        if (treeR->left != NULL) { // если потомок слева, то
            treeR = treeR->left;  // присваиваем удаляемому узлу его значение
        }
        else if (treeR->right != NULL) { // если потомок справа, то
            treeR = treeR->right;  // присваиваем удаляемому узлу его значение
        }
        else { // иначе у узла нет потомков
            treeR = NULL; // удаляем данный узел
        }
    }
    return treeR;
}
 
int main() {
    setlocale(LC_ALL, "RUS");
    Tree* mainTree;
    mainTree = NULL;
    int i = -1;
    int value;
    bool d;
    while (i != 0) {
        std::cout << "1. Добавление элемента в дерево." << std::endl;
        std::cout << "2. Прямой обход" << std::endl;
        std::cout << "3. Уничтожение дерева" << std::endl;
        std::cout << "4. Поиск элемента" << std::endl;
        std::cout << "5. Удаление элемента" << std::endl;
        std::cout << "Введите команду: ";
        std::cin >> i;
        if (i == 1) {
            std::cout << "Введите значение: ";
            std::cin >> value;
            d = treeContains(value, mainTree);
            if (d == true) {
                std::cout << "Данный элемент уже есть в дереве" << std::endl;
            }
            else {
                mainTree = add(value, mainTree);
            }
        }
        else if (i == 2) {
            treePrint(mainTree);
            std::cout << std::endl;
        }
        else if (i == 3) {
            treeDelete(mainTree);
        }
        else if (i == 4) {
            std::cout << "Введите значение: ";
            std::cin >> value;
            treeContains(value, mainTree);
        }
        else if (i == 5) {
            std::cout << "Введите значение: ";
            std::cin >> value;
            mainTree = removeElement(value, mainTree);
            treePrint(mainTree);
            std::cout << std::endl;
        }
    }
    return 0;
}