принята

#include <iostream>

struct Node
{
    int key;
    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 (max_vertex->key <= new_vertex->key && max_vertex->right == NULL)
    {
        new_vertex->parent = max_vertex;
        max_vertex->right = new_vertex;
    }

    else if (max_vertex->right != NULL)
        find_parent(max_vertex->right, tree, new_vertex);

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

int main()
{
    int n;
    int max = -1;

    std::cin >> n;

    Node tree[n];

    tree[0].right = NULL;
    tree[0].left = NULL;
    tree[0].parent = NULL;
    std::cin >> tree[0].key;

    Node* max_vertex = &tree[0];

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

        tree[k].right = NULL;
        tree[k].left = NULL;
        tree[k].parent = NULL;
        std::cin >> tree[k].key;

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

        else
            find_parent(max_vertex, tree, &tree[k]);

        if (max < tree[k].key)
        {
            max = tree[k].key;
            max_vertex = &tree[k];
        }
    }

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

    return 0;
}