Удаление элемента из списка

struct Node {
    int *d;
    int size;
    
    int extendSize(int x);
 
    Node(int size) {
        this->size = extendSize(size);
        this->d = new int[this->size];
        for (int i = 0; i < this->size; i++) {
            d[i] = 0;
        }
    }
};
 
void Tree_Insert(Node *&p, int d);//Добавление элемента
void Tree_Delete(Node *p, int d, int index);//Удаление элемента
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 Tree_Search(Node * p, int d, int index);//поиск (рекурсивно)
int Search_Tree(Node * p, int d, int index);        //поиск 
int Tree_Minimum(Node *p, int index);    //поиска min
int Tree_Maximum(Node *p, int index);    //поиска max
int Tree_Succ(Node *p, int d, int index);      // следующий элемент
int Tree_Pred(Node *p, int d, int index);      // предыдущий элемент
 
int main()
{
    setlocale(0, "");
    int size = 0;
    cout << "Введите размер дерева:  ";
    cin >> size;
    Node *root= new Node(size);
    int x, el = 0;
    cout << "Введите ";
    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 << "Введите элемент для поиска: ";
    cin >> el;
    cout << "Искомый элемент: " << Search_Tree(root, el, 0) << endl;
    cout << "Искомый элемент: " << Tree_Search(root, el, 0) << endl;
    //cout << "Succ = " << Tree_Succ(root, el, 0) << endl;
    //cout << "Pred = " << Tree_Pred(root, el, 0) << endl;
    cout << "Удаление элемента дерева  "; Tree_Delete(root, el, 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 d, int index)
{
 
    if (p->d[index] == 0) return;
 
    if (p->d[index] > d)
        Tree_Delete(p, d, 2 * index + 1);
 
    else if (p->d[index] < d)
        Tree_Delete(p, d, 2 * index + 2);
 
    else {
        if (p->d[2 * index + 1] == 0 && p->d[2 * index + 2] == 0) {
            delete &p->d[index];
            p->d[index] = 0;
        }
 
        else if (p->d[2 * index + 1] && p->d[2 * index + 2]) {
            int pred = Tree_Minimum(p, 2 * index + 2);
            p->d[index] = pred;
            Tree_Delete(p, pred, 2 * index + 1);
        }
 
        else {
            int child = (p->d[2 * index + 1]) ? p->d[2 * index + 1] : p->d[2 * index + 2];
            int curr = p->d[index];
            p->d[index] = child;
            delete &child;
        }
    }
}
 
void Tree_Destroy(Node *p, int index) {
    if (p != NULL) {
        Tree_Destroy(p, 2 * index + 1);
        Tree_Destroy(p, 2 * index + 2);
        delete &p->d[index];
    }
}
 
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 Tree_Search(Node * p, int d, int index)
{
    if (p == 0 || p->d[index] == d)
        return p->d[index];
    if (d < p->d[index])
        Tree_Search(p, d, 2 * index + 1);
    else
        Tree_Search(p, d, 2 * index + 2);
}
 
int Search_Tree(Node * p, int d, int index)
{
    while (true) {
        if (p->d[index] == NULL) 
            break;
        if (p->d[index] == d) {
            return p->d[index];
            break;
        }
        else if (p->d[index] < d) {
            index = (2 * index + 2);
        }
        else if (p->d[index] > d) {
            index = (2 * index + 1);
        }
    }
}
 
int Tree_Minimum(Node *p, int index)
{
    int min = 0;
    while (p->d[2 * index + 1] != 0) {
        min = p->d[2 * index + 1];
        index++;
    }
    return min;
}
 
int Tree_Maximum(Node * p, int index)
{
    int max = 0;
    while (p->d[2 * index + 2] != 0) {
        max = p->d[2 * index + 2];
        index+=2;
    }
    return max;
}