Как к дереву добавлять элементы?

Tree t = new NODE("значение");

#pragma once
#include <iostream>
#include <fstream>
 
using TInfo = int;
 
struct NODE
{
    TInfo info;
    NODE* left, * right;
    int count = 0;
    NODE() {}
    NODE(TInfo info, NODE* left = nullptr, NODE* right = nullptr) :info(info), left(left), right(right) {}
    ~NODE()
    {
        left = nullptr;
        right = nullptr;
    }
};
 
using Tree = NODE*;
 
Tree Build_Balance(std::ifstream& file, int count)
{
    Tree result = nullptr;
    if (count)
    {
        int count_left = count / 2;
        int count_right = count - count_left - 1;
        int x;
        file >> x;
        result = new NODE(x);
        result->left = Build_Balance(file, count_left);
        result->right = Build_Balance(file, count_right);
    }
    return result;
}
 
void Clear(Tree& t)
{
    if (t)
    {
        Clear(t->left);
        Clear(t->right);
        delete t;
        t = nullptr;
    }
}
 
void Print(Tree t, int level = 0)
{
    if (t)
    {
        Print(t->right, level + 1);
        for (int i = 1; i <= level; ++i)
            std::cout << "   ";
        std::cout << t->info << '\n';
        Print(t->left, level + 1);
    }
}
 
void find_element(Tree& r, Tree& q)
{
    if (r->right)
        find_element(r->right, q);
    else
    {
        q->info = r->info;
        q->count = r->count;
        q = r;
        r = r->left;
    }
}
 
bool delete_element(Tree& t, TInfo elem)
{
    bool result = false;
    if (t)
    {
        if (elem < t->info)
            result = delete_element(t->left, elem);
        else
            if (elem > t->info)
                result = delete_element(t->right, elem);
            else
            {
                if (t->count > 1)
                    t->count--;
                else
                {
                    Tree q = t;
                    if (!t->right)
                        t = q->left;
                    else
                        if (!t->left)
                            t = q->right;
                        else
                            find_element(q->left, q);
                    delete q;
                }
                result = true;
            }
    }
    return result;
}

//Рекурсивное построение
Tree task_10(int n)
{
    Tree result = nullptr;
    if (n)
    {
        result = new NODE(n);
        result->left = task_10(n - 1);
        result->right = task_10(n - 1);
    }
    return result;
}
 
//Нерекурсивное построение
void task_10_1(int n)
{
    Tree result = new NODE(n--);
 
    result->left = new NODE(n);
    result->right = new NODE(n--);
 
    result->left->left = new NODE(n);
    result->left->right = new NODE(n);
    Print(result);
}

#include <iostream>
#include <queue>
#include <iomanip>
 
struct Tree {
    int value;
    Tree *left;
    Tree *right;
    Tree(int value) : value(value), left(nullptr), right(nullptr) {}
};
 
Tree *buildSpecialTree(int n) {
    std::queue<std::pair<Tree*, int>> queue;
    Tree *root = new Tree(n);
    queue.push({root, n - 1});
    while (!queue.empty()) {
        auto task = queue.front();
        queue.pop();
        task.first->right = new Tree(task.second);
        task.first->left = new Tree(task.second);
        if (task.second > 1) {
            queue.push({task.first->right, task.second - 1});
            queue.push({task.first->left, task.second - 1});
        }
    }
    return root;
}
 
template<typename Visitor>
void traverseInOrder(Tree *root, Visitor visitor) {
    if (root) {
        traverseInOrder(root->left, visitor);
        visitor(root->value);
        traverseInOrder(root->right, visitor);
    }
}
 
void clear(Tree *root) {
    if (root) {
        clear(root->left);
        clear(root->right);
        delete root;
    }
}
 
int main() {
 
    Tree *root = buildSpecialTree(4);
    traverseInOrder(root, [](int value) { std::cout << std::setw(value * 2) << value << std::endl; });
    clear(root);
 
    return 0;
}

#include <iostream>
#include <queue>
#include <iomanip>
 
struct Tree {
    int value;
    Tree *left;
    Tree *right;
    Tree(int value) : value(value), left(nullptr), right(nullptr) {}
};
 
Tree *buildSpecialTree(int n) {
    Tree *root = new Tree(n--);
    for (Tree *parent = root; n > 0; --n) {
        parent = parent->left = parent->right = new Tree(n);
    }
    return root;
}
 
template<typename Visitor>
void traverseInOrder(Tree *root, Visitor visitor) {
    if (root) {
        traverseInOrder(root->left, visitor);
        visitor(root->value);
        traverseInOrder(root->right, visitor);
    }
}
 
void clear(Tree *root) {
    if (root) {
        clear(root->left);
        clear(root->right);
        delete root;
    }
}
 
int main() {
 
    Tree *root = buildSpecialTree(4);
    traverseInOrder(root, [](int value) { std::cout << std::setw(value * 2) << value << std::endl; });
    clear(root);
 
    return 0;
}