Deletion in binary search tree

Question

So when I delete in binary search tree, do I need to have like 7 different cases ie

1. Left Leaf;
2. Right Leaf;
3. Left child with only left child. //ie the node to be deleted is the left child of it's parent and it has only left child.
4. Left Child with only right child.
5. Right child with only left child.
6. Right child with only right child.
7. Node to be deleted has both the children ie right and left.

Now when this code is using if-else it gets pretty nasty.. is there any other way of doing this.

Here is my code snippet

if(current->left==NULL && current->right==NULL && current->key<prev->key)   //left leaf
prev->left=NULL;
else if(current->left==NULL && current->right==NULL && current->key>prev->key) // right     leaf
prev->right=NULL;
else if(current->left!=NULL && current->right==NULL && current->key<prev->key) // left     child with one child
prev->left=current->left;
else if(current->left==NULL && current->right!=NULL && current->key<prev->key)
prev->left=current->right;
else if(current->left!=NULL && current->right==NULL && current->key>prev->key)
prev->right=current->left;
else if(current->left==NULL && current->right!=NULL && current->key>prev->key)
prev->right=current->left;
else if(current->left!=NULL && current->right!=NULL)
{
    check=current->right;
    check1=check;
    while(check->left!=NULL)
    {
    check1=check;
    check=check->left;
    }
    *current=*check;
    check1->left=NULL;
}

Answer 1

You can keep it a lot simpler than that, and simply restrict yourself to three cases when deleting a node from a BST (binary search tree) :

1. a node without children (a leaf) : just remove it - nothing special needs to be done
2. a node with one child : remove it, and move the child in its place
3. a node with two children : swap it with either its in-order predecessor or successor, and then remove it

The wiki page contains an example of how this could look in code.

Or as a very basic example in C :

if (current->left==NULL && current->right==NULL) {
    /* leaf node */
    bst_replace(current, NULL);
}
else if (current->left==NULL || current->right==NULL) {
    /* node with one child */
    bst_replace(current, ((current->left) ? current->left : current->right));
}
else {
    /* node with two children */
    Node* successor = bst_next(current);
    current->data = successor->data;
    bst_replace(successor, successor->right);
}

Answer 2

I don't really understand the protocol used for deleting here. You seem to not have a binary 'search' tree (no ordering in the tree).

But to just make the code simple. You could do something like this:

bool b1 = (current->left == NULL);
bool b2 = (current->right == NULL);
bool b3 = (current->key > prev->key);

int decision_case = b1 * 4 + b2 * 2 + b3;

switch(decision_case) {
  case 0: // fill in code here
          break;
  ...
  ...
  case 7: // fill in code here
          break;
}

Also, you should use delete to avoid memory leaks here. Hope that helps.

Answer 3

Deleting a NULL pointer has no ill effect. So, you should be able to do this with no special cases. The basic part is just:

delete current->left;
delete current->right;