Нахождение min & max элемента в BST

struct Node {
    int *d;
    int size;
    
    int extendSize(int x);
 
    Node(int s) {
        size = extendSize(s);
        d = new int[size];
        for (int i = 0; i < size; i++) {
            d[i] = NULL;
        }
    }
};void Tree_Insert(Node *&p, int d);//Добавление элемента
void Tree_Delete(Node *p, int d);//Удаление элемента
void Tree_Destroy(Node *p, int index);      //удаление всего дерева
void preorder_Tree(Node * p, int index); //Прямой обход
void postorder_Tree(Node * p, int index);//Обратный обход
void inorder_Tree(Node * p, int index);//Симметричный обход
int Search_Tree(Node * p, int d);//поиск 
int Tree_Minimum(Node *p, int index)
{
    int min = 0;
    while (p->d[2 * index + 1] != NULL)
        min = p->d[2 * index + 1];
    return min;
}
 
int Tree_Maximum(Node * p, int index)
{
    int max = 0;
    while (p->d[2 * index + 2] != NULL)
        max = p->d[2 * index + 2];
    return max;
}
int main()
{
    setlocale(0, "");
    int size = 0;
    cout << "Введите размер дерева:  ";
    cin >> size;
    Node *root= new Node(size);
    int x, el = 0;
    cout << "Введите " << endl;
    for (int i = 0; i < size; i++)
    {
        cin >> x;
        Tree_Insert(root, x);
    }
    cout << "Прямой обход дерева ";
    preorder_Tree(root, 0); cout << endl;
    cout << "Обратный обход дерева ";
    postorder_Tree(root, 0); cout << endl;
    cout << "Симметричный обход дерева ";
    inorder_Tree(root, 0); cout << endl;
    cout << "Min = " << Tree_Minimum(root, 0) << endl; 
    cout << "Max = " << Tree_Maximum(root, 0) << endl; 
    cout << "Удаление дерева";
    Tree_Destroy(root, 0); cout << endl;
 
    system("pause");
    return 0;
}
 
int Node::extendSize(int x)
{
    int value = 0;
    for (int y = 0; y < x + 1; y++) {
        value = (2 * value) + 2;
    }
    return value;
}
 
void Tree_Insert(Node *&p, int d)
{
    int index = 0;
    while (true) {
        if (p->d[index] == NULL) {
            p->d[index] = d;
            break;
        }
        else if (p->d[index] <= d) {
            if (p->d[index] == d) 
                break;
            else
                index = (2 * index + 2);
        }
        else if (p->d[index] >= d) {
            if (p->d[index] == d)
                break;
            else
                index = (2 * index + 1);
        }
    }
}
 
void Tree_Delete(Node *p, int index, int d)
{
    Node *
}
 
void Tree_Destroy(Node *p, int index) {
    if (p->d[index] != NULL) {
        Tree_Destroy(p, 2 * index + 1);
        Tree_Destroy(p, 2 * index + 2);
        delete p;
    }
}
 
void preorder_Tree(Node * p, int index)
{
    if (p->d[index] != NULL) {
        cout << p->d[index] << " ";
        preorder_Tree(p, 2 * index + 1);
        preorder_Tree(p, 2 * index + 2);
    }
}
 
void postorder_Tree(Node * p, int index)
{
    if (p->d[index] != NULL) {
        postorder_Tree(p, 2 * index + 1);
        postorder_Tree(p, 2 * index + 2);
        cout << p->d[index] << " ";
    }
}
 
void inorder_Tree(Node * p, int index)
{
    if (p->d[index] != NULL) {
        inorder_Tree(p, 2 * index + 1);
        cout << p->d[index] << " ";
        inorder_Tree(p, 2 * index + 2);
    }
}
 
int Search_Tree(Node * p, int d)
{
    int index = 0;
    while (true) {
        if (p->d[index] == NULL) 
            break;
        if (p->d[index] == d) {
            return index;
            break;
        }
        else if (p->d[index] < d) {
            index = (2 * index + 2);
        }
        else if (p->d[index] > d) {
            index = (2 * index + 1);
        }
    }
}