Функция удаления листа (или ветки) бинарного дерева

#include <iostream>
using namespace std;
 
 
struct Node { 
    int value;
    Node *left; 
    Node *right; 
};
 
void add(Node*& p, int value);
void print( Node* p, int level=1 );
Node *del(Node* p,int key);
 
void main() { 
    Node *root = NULL;
    int b[] = {10, 25, 20, 6, 21, 8, 1, 30};
    //cout <<"vvedite 4isla ";
    for( int i = 0; i < 8; i++ ) {
        add(root, b[i]);
    }
 
    for( int i = 0; i < 8; i++ ) {
        cout <<"\n\n"; 
        root = del(root, b[i]);
        print(root);
    }
       
    system("pause");
}
 
void add(Node*& p, int value) { 
    if (p == NULL) {
        p = new Node; 
        p->left = NULL; 
        p->right = NULL; 
        p->value = value; 
    } else { 
        if( value < p->value ) {
            add(p->left, value);  
        } else if( value > p->value ) {
            add(p->right, value);  
        }
    }
}
 
void print( Node* p, int level ) { 
    if( p != NULL ) {
        cout << "Level " << level << ", Value: " << p->value << endl;
    } else if( level == 1 ){
        cout << "Empty tree!" << endl;
        return;
    }
    if( p->left != NULL ) {
        print(p->left, level + 1);
    }
    if( p->right != NULL ) {
        print(p->right, level + 1);
    }
}
 
Node* search(Node* p, int key) {
    if( p == NULL ) { 
        return NULL;
    }
 
    if( key == p->value ) {
        return p;
    } else if( key < p->value ) {
        return search(p->left, key);
    } else {
        return search(p->right, key);
    }
}
 
Node *parent(Node *p, Node *del_p, int key) {
    if( p == NULL ) {
        return NULL;
    }
    if( p->left == del_p || p->right == del_p || p == del_p ) {
        return p;
    }
 
    if( key < p->value ) {
        return parent(p->left, del_p, key);
    } else {
        return parent(p->right, del_p, key);
    }
}
 
Node* find_ld(Node *p) {
    if( p == NULL ) {
        return NULL;
    }
    if( p->left != NULL ) {
        return find_ld(p->left);
    }
    return p;
}
 
Node *del(Node* p, int key) {
    if( p->left == NULL && p->right == NULL ) {
        delete p;
        return NULL;
    }
 
    Node *root = p;
 
    Node* del_p = search(p, key);
    Node* pd = parent(p, del_p, key);
 
    Node* ld = find_ld(del_p->right);
    
    if( ld == NULL ) {
        if( pd->left == del_p ) {
            pd->left = del_p->left;
        } else {
            pd->right = del_p->right;
        }
 
        delete del_p;
        return p;
    }
    Node* pld = parent(p, ld, ld->value);
    
    if( pd == del_p ) {
        pd = ld;
        root = NULL;
    } else if( pd->left == del_p ) {
        pd->left = ld;
    } else {
        pd->right = ld;
    }
 
    if( pld->left == ld ) {
        pld->left = ld->right;
        ld->left = del_p->left;
        ld->right = del_p->right;
    } else {
        pld->right = ld->right;
        ld->left = del_p->left;
    }
 
    delete del_p;
    return (root == NULL)? pd: root;
}