Бинарные деревья, С++

#include <iostream>
#include <ctime>
#include <string>
 
using namespace std;
struct Tree {
    int data;
    Tree* left, * right;
};
void add(int x, Tree*& p)
{
    int i = rand() % 2;
 
    if (p == NULL)
    {
        p = new Tree;
        p->data = x;
        p->right = p->left = NULL;
        return;
    }
 
    if (i == 0) add(x, p->right);
    else add(x, p->left);
}
int element_depth(int b, Tree*& p, int depth) {
    if (p != NULL) {
        depth++;
        if (b == p->data)
            return depth;
        else {
            int d;
            d = element_depth(b, p->left, depth);       // сначала рекурсивный обход левого поддерева
            if (d == -1)                                // не нашли?
                d = element_depth(b, p->right, depth);  // тогда рекурсивный обход правого поддерева
            return d;
        }
    }
 
    else
        return -1;
}

.........................
    else
        return -1;
}
 
int main()
{
здесь ввод данных - добавление их в список - расчёты - вывод результатов
}

       return -1;
    }
    int main()
    {
        int n;
        int a;
        
        cout << "Enter N: ";
        cin >> n;
        while (--n > -1)
        {
            cin >> a;
           
        }
        
    }

      else
            return -1;
    }
    int main()
    {
        int n;
        int a;
        
        cout << "Enter N: ";
        cin >> n;
        while (--n > -1)
        {
            cin >> a;
            cout << a<<" ";
        }
        return -1;
    }

int main()
{
    int n;
    int a;
        
    Tree *root = nullptr;
 
    cout << "Enter N: ";
    cin >> n;
    while (--n > -1)
    {
        cin >> a;
        add(a, root);   
    }
 
    cout << "Enter X: ";
    cin >> a;
 
    std::cout << element_depth(a, root, 0) << std::endl;
    return -1;
}

#include <iostream>
#include <ctime>
#include <string>
 
using namespace std;
    //структура дерева
struct Tree {
    int data;
    Tree* left, * right;
};
void show(Tree*& root)              //Функция обхода
{
    if (root != NULL)               //Пока не встретится пустое звено
    {
        show(root->left);               //Рекурсивная функция для вывода левого поддерева
        cout << root->data << '\t';               //Отображаем корень дерева
        show(root->right);               //Рекурсивная функци для вывода правого поддерева
    }
}
 
/*Добавили очистку памяти*/
void del(Tree*& root) {
    if (root != NULL)                //Пока не встретится пустое звено
    {
        del(root->left);                //Рекурсивная функция прохода по левому поддереву
        del(root->right);                //Рекурсивная функци для прохода по правому поддереву
        delete root;                 //Убиваем конечный элемент дерева
        root = NULL;                 //Может и не обязательно, но плохого не будет
    }
 
}
    //формирование дерева выполняется случайным образом
    void add(int x, Tree * &p)
        {
            if (p == NULL)
            {
                p = new Tree;
                p->data = x;
                p->right = p->left = NULL;
                
            }
            if (x < p->data)               //Если нововведенный элемент x меньше чем элемент x из семечка дерева, уходим влево
            {
                if (p->left != NULL) add(x, p->left); //При помощи рекурсии заталкиваем элемент на свободный участок
                else                      //Если элемент получил свой участок, то
                {
                    p->left = new Tree;                 //Выделяем память левому подзвену. Именно подзвену, а не просто звену
                    p->left->left = p->left->right = NULL;   //У левого подзвена будут свои левое и правое подзвенья, инициализируем их пустотой
                    p->left->data = x;                     //Записываем в левое подзвено записываемый элемент
                }
            }
 
            if (x > p->data)          //Если нововведенный элемент x больше чем элемент x из семечка дерева, уходим вправо
            {
                if (p->right != NULL) add(x, p->right); //При помощи рекурсии заталкиваем элемент на свободный участок
                else                                          //Если элемент получил свой участок, то
                {
                    p->right = new Tree;                 //Выделяем память правому подзвену. Именно подзвену, а не просто звену
                    p->right->left = p->right->right = NULL;   //У правого подзвена будут свои левое и правое подзвенья, инициализируем их пустотой
                    p->right->data = x;                     //Записываем в правое подзвено записываемый элемент
                }
            }
    }
 
    int element_depth(int b, Tree * &p, int depth) {
        if (p != NULL) {
            depth++;
            if (b == p->data)
                return depth;
            else {
                int d;
                d = element_depth(b, p->left, depth);       // сначала рекурсивный обход левого поддерева
                if (d == -1)                                // если не нашли тот самый элемент
                    d = element_depth(b, p->right, depth);  // тогда рекурсивный обход правого поддерева
                return d;
            }
        }
        else
            return -1;
    }
    int main()
    {
        int n,i;
        int a;
        Tree* root = nullptr;//присваиваем адрес 0 к кореню дерева
        for (i = 20; i > 5; i--) i = rand() % 100; add(i, root);        //На месте спиленного дерева можно растить новое
        show(root);                       //Смотрим, что выросло
        del(root);
        
        cout << "Enter N: ";
        cin >> n;
        while (--n > -1)
        {
            cin >> a;
            add(a, root);
        }
 
        cout << "Enter A: ";
        cin >> a;
 
        cout << element_depth(a, root, 0) << endl;//вывод глубины выбранного элемента
        return -1;
    }

void add(int x, Tree*& p)
        {
        int i = rand() % 2;
 
        if (p == NULL)
        {
            p = new Tree;
            p->data = x;
            p->right = p->left = NULL;
            return;
        }
 
        if (i == 0) add(x, p->right);
        else add(x, p->left);
    }

    int main()
    {
srand(time(0));
        int n,i;
        int a;
        Tree* root = nullptr;//присваиваем адрес 0 к кореню дерева

void add(int x, Tree*& p)
{
    if (p == NULL)
    {
        p = new Tree;
        p->data = x;
        p->right = p->left = NULL;
    }
    else if (x < p->data) 
        add(x, p->left);
    else
        add(x, p->right);
}

void show(Tree*& root, std::string tabs = {})              //Функция обхода
{
    if (root != NULL)               //Пока не встретится пустое звено
    {
        show(root->left, tabs + ".");               //Рекурсивная функция для вывода левого поддерева
        cout << tabs << root->data << std::endl;               //Отображаем корень дерева
        show(root->right, tabs + ".");               //Рекурсивная функци для вывода правого поддерева
    }
}