без принтов

#include <iostream>
using namespace std;

struct Node
{
    int key;
    int idx;
    Node* left;
    Node* right;
    Node* parent;
};

void preorderTraversal(Node* x)
{
    if (x != NULL)
    {
        std::cout << x->key << " ";
        preorderTraversal(x->left);
        preorderTraversal(x->right);
    }
    return;
}

void inorderTraversal(Node* x)
{
    if (x != NULL)
    {
        inorderTraversal(x->left);
        std::cout << x->key << " ";
        inorderTraversal(x->right);
    }
    return;
}

void postorderTraversal(Node* x)
{
    if (x != NULL)
    {
        postorderTraversal(x->left);
        postorderTraversal(x->right);
        std::cout << x->key << " ";
    }
    return;
}

void print_tree(Node* tree, int n)
{
    std::cout << std::endl;
    for (int i = 0; i < n; ++i)
    {
        std::cout << "i= " << tree[i].key << ": ";
        if (tree[i].left != NULL)
            std::cout << tree[i].left->key << " ";
        if (tree[i].right != NULL)
            std::cout << tree[i].right->key << " ;";
        std::cout << std::endl;
    }
    std::cout << std::endl;
}

void find_parent(Node* max_vertex, Node* tree, Node* new_vertex)
{

    if (tree[0].key <= new_vertex->key && tree[0].right == NULL)
    {
        new_vertex->parent = &tree[0];
        tree[0].right = new_vertex;
    }

    else
    {
        if (my_pointer->key <= new_vertex->key && my_pointer->right == NULL)
        {
            new_vertex->parent = my_pointer;
            my_pointer->right = new_vertex;
        }

        else
        {
            if (my_pointer->right != NULL)
            {
                find_parent(my_pointer->right, tree, new_vertex);
            }

            else
            {
                find_parent(my_pointer->left, tree, new_vertex);
            }

        }
    }
}

int main()
{
    int n;
    std::cin >> n;

    Node tree[n];
    for (int i = 0; i < n; ++i)
    {
        tree[i].right = NULL;
        tree[i].left = NULL;
        tree[i].parent = NULL;
        tree[i].idx = i;
        std::cin >> tree[i].key;
    }

    Node max_vertex = tree[0];

    for (int k = 0; k < n - 1; ++k)
    {

        if (max_vertex.key < tree[k].key)
            max_vertex = tree[k];

        if (tree[k + 1].key < tree[k].key)
        {
            tree[k].left = &tree[k + 1];
            tree[k + 1].parent = &tree[k];
        }

        else
        {
            find_parent(&max_vertex, tree, &tree[k + 1]);
        }

    }

    print_tree(tree, n);

    postorderTraversal(&tree[0]);
    std::cout << std::endl;
    inorderTraversal(&tree[0]);

    return 0;
}