BST на базе массива

struct Node {
    int d;
    Node* father, * left, * right;
    Node() { father = left = right = 0; };
};
Node *root = 0;
 
void Tree_Insert(Node *&p, int d);//Добавление элемента
void Tree_Delete(Node *p);//Удаление 
void Tree_Destroy(Node *p);      //удаление всего дерева
void direct_bypass(Node * p); //Прямой обход
void reverse_bypass(Node * p);//Обратный обход
void symmetrical_bypass(Node * p);//Симметричный обход
Node * Search_Tree(Node * p, int d);//поиск 
Node *Tree_Minimum(Node *x);    //поиска min
Node *Tree_Maximum(Node *x);    //поиска max
Node * Tree_Succ(Node *p);      // следующий элемент
Node * Tree_Pred(Node *p);      // предыдущий элемент
 
int main()
{
    setlocale(0, "");
    int x, el=0;
    cout << "Введите " << endl;
    for (int i = 0; i < 7; i++) 
    {
        cin >> x; 
        Tree_Insert(root, x);
    }
    cout << "Прямой обход дерева ";
    direct_bypass(root); cout << endl;
    cout << "Обратный обход дерева ";
    reverse_bypass(root); cout << endl;
    cout << "Симметричный обход дерева ";
    symmetrical_bypass(root); cout << endl;
    cout << "Введите элемент для поиска: ";
    cin >> el;
    cout << Search_Tree(root, el)->d << endl;
    cout << "Succ = " << Tree_Succ(Search_Tree(root, el))->d << endl;
    cout << "Prev = " << Tree_Pred(Search_Tree(root, el))->d << endl;
    //cout << "Удаление узла дерева";
    //Tree_Delete(Search_Tree(root, el)); cout << endl;
    cout << "Симметричный обход дерева ";
    symmetrical_bypass(root); cout << endl;
    cout << "Min = " << Tree_Minimum(root)->d << endl;
    cout << "Max = " << Tree_Maximum(root)->d << endl;
    cout << "Удаление дерева";
    Tree_Destroy(root); cout << endl;
 
    system("pause");
    return 0;
}
 
void Tree_Insert(Node *&p, int d)
{
    if (p == 0)
    {
        p = new Node;
        p->d = d;
        p->left = p->right = NULL;
    }
    if (d < p->d)
    {
        if (p->left != NULL)
            Tree_Insert(p->left, d);
        else
        {
            p->left = new Node;
            p->left->left = p->left->right = NULL;
            p->left->d = d;
        }
    }
    if (d > p->d)
    {
        if (p->right != NULL)
            Tree_Insert(p->right, d);
        else
        {
            p->right = new Node;
            p->right->left = p->right->right = NULL;
            p->right->d = d;
        }
    }
}
 
void Tree_Delete(Node *p)
{
    Node *x, *y;
    if (root && p) {
        if (p->left == 0 || p->right == 0) y = p;
        else y = Tree_Succ(p);
        if (y->left) x = y->left;
        else x = y->right;
        if (x) x->father = y->father; 
        if (y->father == 0) root = x; 
        else {
            if (y == y->father->left) y->father->left = x;
            else y->father->right = x;
        }
        if (y != p) p->d = y->d; 
        delete y;
    }
}
 
void Tree_Destroy(Node *p) {
    if (p != NULL) {
        Tree_Destroy(p->left);
        Tree_Destroy(p->right);
        delete p;
    }
}
 
void direct_bypass(Node * p)
{
 
    if (p)
    {
        cout << p->d << " ";
        direct_bypass(p->left);
        direct_bypass(p->right);
    }
}
 
void reverse_bypass(Node * p)
{
    if (p)
    {
        reverse_bypass(p->left);
        reverse_bypass(p->right);
        cout << p->d << " ";
    }
}
 
void symmetrical_bypass(Node * p)
{
    if (p)
    {
        symmetrical_bypass(p->left);
        cout << p->d << " ";
        symmetrical_bypass(p->right);
    }
}
 
Node * Search_Tree(Node * p, int d)
{
    while (p != 0 && d != p->d)
        if (d < p->d) p = p->left;
        else p = p->right;
    return p;
 
}
 
Node *Tree_Minimum(Node *x)
{
    while (x->left != NULL)
        x = x->left;
    return x;
}
 
Node * Tree_Maximum(Node * x)
{
    while (x->right != NULL)
        x = x->right;
    return x;
}
 
Node * Tree_Succ(Node * p)
{
    Node *y;
    if (p->right) return Tree_Minimum(p->right);
    y = p->father;
    while (y != 0 && p == y->right)
    {
        p = y;
        y = y->father;
    }
    return y;
}
 
Node * Tree_Pred(Node * p)
{
    Node *y;
    if (p->left) return Tree_Maximum(p->left);
    y = p->father;
    while (y != 0 && p == y->left)
    {
        p = y;
        y = y->father;
    }
    return y;
}

int *symmetrical_bypass(Node * p, int *arr)
{
    if (!p)
        return arr;
 
    arr = symmetrical_bypass(p->left, arr);
    *(arr++) = p->d;
    return symmetrical_bypass(p->right, arr);
}
 
 
.................
 
cout << "Введите " << endl;
for (int i = 0; i < 7; i++)
{
    cin >> x;
    Tree_Insert(root, x);
}
int arr[7];
symmetrical_bypass(arr);