仅包含root的二进制搜索树，删除导致打印无限数量的地址

Question

This code:

1. inserts
2. searches
3. prints various traversals
4. deletes

Deletion is where the problem lies,i have done this code on my own(so this might not be the regular method).I have seperated deletion into three parts where checking occurs:

1. if target node is with two child nodes
2. if target node is with one child node
3. if target node is with no child node

Every part of this program run correclty,correct outputs(just everything!) except when root is the only node left and we are trying to delete the root.

It enters nonode function(in the function there is special case for root) and even prints "you have deleted the only node in memory".Gives all the options once again.however selecting any option after that shows an error.In trying printing of various traversals for example it prints an infinite list of addresses on checking traversal and ultimately the .exe file stops instead of printing "no binary tree in memory".

#include <stdio.h>
#include <stdlib.h>

struct bt
{
    struct bt *left;
    int data;
    struct bt *right;
};

struct bt *root=NULL,**sp=NULL;

void insertion(struct bt**,int);
void prtraversal(struct bt**);
void intraversal(struct bt**);
void potraversal(struct bt**);
void search(struct bt**,int);
void del(struct bt **n,int key); 
void nonode(struct bt **n); 
void onenode(struct bt **n);
void bothnode(struct bt **n);

main()
{
    int ch,key;
    printf("******\n\n The program automatically avoids inclusion of repeat numbers\n\n**********");
    while(1)
    {
        printf("\nenter your choice\n1 for insertion\n2 for search\n3 for Various Traversal\n4 for deletion\n5 for exit\n");
        scanf("%d",&ch);
        switch(ch)
        {
        case 1:
            printf("Enter your Key for insertion\n");
            scanf("%d",&key);
            insertion(&root,key);
            break;
        case 2:
            if(root!=NULL)
            {
                printf("Enter your Key for search\n");
                scanf("%d",&key);
                search(&root,key);
            }
            else
            {
                printf("\n NO BINARY TREE IN MEMORY\n");
            }
            break;
        case 3:
            if(root!=NULL)
            {
                printf("\n\nPREORDER TRAVERSAL:");
                prtraversal(&root);
                printf("\n\nINORDER TRAVERSAL:");
                intraversal(&root);
                printf("\n\nPOSTORDER TRAVERSAL:");
                potraversal(&root);
            }
            else
            {
                printf("\n NO BINARY TREE IN MEMORY\n");
            }
            break;
        case 4:
            if(root!=NULL)
            {
                printf("Enter your Key for Delete\n");
                scanf("%d",&key);
                del(&root,key);
            }
            else
            {
                printf("\n NO BINARY TREE IN MEMORY\n");
            }
            break;
        case 5:
            exit(1);
        default:
            printf("\n Wrong Choice\n");
        }
        sp=NULL;
    }
}

void del(struct bt **n,int key)
{
    if((*n)!=NULL)
    {
        if(key<(*n)->data)
            del(&((*n)->left),key);
        else if(key>(*n)->data)
            del(&((*n)->right),key);
        else if(key==(*n)->data)
        {
            printf("\nELEMENT FOUND\n");
            printf("\n DELETION UNDERWAY\n");
            sp=n;
            if(((*n)->right)!=NULL && ((*n)->left)!=NULL)
            {
                bothnode(&((*n)->left));
            }
            else if(((*n)->right)!=NULL && ((*n)->left)==NULL)
            {
                onenode(&((*n)->right));
            }
            else if(((*n)->left)!=NULL && ((*n)->right)==NULL)
            {
                onenode(&((*n)->left));
            }
            else if(((*n)->left)==NULL && ((*n)->right)==NULL)
            {
                nonode(&root);
            }
        }
    }
    else
    {
        printf("\nELEMENT NOT FOUND\n");
    }
}

void nonode(struct bt **n) //deletes the target node without any child,root address is provided to struct bt **n
{
    struct bt **parent=n;//stores address of node just before target node,will be updated in this function
    if(sp!=&root)//target node address stored in sp from a previous function
    {
        while((*n)->data!=(*sp)->data)//to find address of node just before target node and store it in struct bt **parent
        {
            parent=n;//frequent parent update as struct bt **n traverses tree
            if(((*sp)->data)<((*n)->data))
                n=&((*n)->left);
            if(((*sp)->data)>((*n)->data))
                n=&((*n)->right);
        }
        if((*parent)->right==(*sp))//checks if parent's right contains address of target node
        {
            (*parent)->right=NULL;
            free(*sp);
        }
        else if((*parent)->left==(*n))//else checks if parent's left contains address of target node
        {
            (*parent)->left=NULL;
            free(*n);
        }
    }
    else if(sp==&root)//if the root node has to be deleted,no child on either side,only one node in tree
    {
        free(*sp);
        printf("\nYOU DELETED THE ONLY NODE IN MEMORY\n");
    }
}

Answer 1

You are not setting root to NULL when you are deleting a single node from the tree. Since, root is global you can set it to NULL inside del(struct bt **n,int key) . By the time you reach this check:

else if(((*n)->left)==NULL && ((*n)->right)==NULL)

you already know that you are going to delete the root node because the previous conditions have exhausted all other possibilities. So you can simply free the root node and set it to NULL

else
{
    free(*n);
    *n = NULL;
}

On a side note, your deletion algorithm is very complex. In order to delete a node in a BST, you can simply replace its key with that of the largest node in the left subtree or the smallest node in the right subtree and then delete the substituted node.

Answer 2

Your posted code is flawed in the del() function for removing a leaf-node. You're assuming a leaf node is the root node. It might be, but that isn't the point.

This:

else if(((*n)->left)==NULL && ((*n)->right)==NULL)
{
    nonode(&root);
}

Should simply do this:

else nonode(n);

Reason: You already check the prior two conditions, you already know this pointer has no chidden. In actuality, nonode() isn't even needed. You could simply do this:

else
{
    free(*n);
    *n = NULL;
}

The whole point of passing in pointers by address is you have access to modify them. So do so. This node is being deleted and you have the address of the pointer that is referencing it. Delete the node and set that pointer to NULL. If that pointer happens to be root so be it; it will be NULL when the function is finished.

Answer 3

You forgot to set your root to NULL after deleting:

else if(sp==&root)
{
    free(*sp);
    *sp = NULL;                                         // <-- add this line
    printf("\nYOU DELETED THE ONLY NODE IN MEMORY\n");
}

Answer 4

this is a very confusing way to free up a binary tree. pointers to pointers, different functions for deleting nodes. I believe something like this should work find, you can put in your prints where wanted

void wrap_del(strut tree ** t)
{
    del(*t);
    *t = NULL;
}

void del(struct tree * t)
{
    if (*t == NULL)
        return; //called on a null ptr

    del(t->left);
    del(t->right);
    free(t);
}

this recursive call will go all the way to the bottom of the tree, return when it is called on a null node, and after returning from deleting the left and right, will then free up itself