Printing a pointer after its deletion prints null between parentheses - c

Question

I wrote a piece of code that recursively finds the smallest string in a tree and deletes it. However, printing the tree after deleting the node returns (null).
static char* findMinimum(TreeNodePtr treePtr){
if(treePtr->left == NULL){
printf("Minimum node is %s\n", treePtr->item);
char * temp = treePtr->item;
(treePtr)->item = NULL;
return(temp);
}
else{
findMinimum(treePtr->left);
}
}
I THINK this function works since it deletes the minimum value even using different strings. Should I write a condition to make sure NULL pointers won't get printed? Just in case, here's the print function as well:
static void printTree(TreeNodePtr treePtr) {
if (treePtr != NULL) {
level++;
printTree(treePtr->left);
printf(">%*s%s\n", level*5, "", treePtr->item);
printTree(treePtr->right);
level--;
}
}

Answer 1

I see couple of problems in your findMinimum function:
1) What do you return in else-case in findMinimum? I guess you forgot to add return:
static char* findMinimum(TreeNodePtr treePtr){
if(treePtr->left == NULL){
printf("Minimum node is %s\n", treePtr->item);
char * temp = treePtr->item;
(treePtr)->item = NULL;
free(treePtr->item);
return(temp);
}
else{
return findMinimum(treePtr->left); // added return
}
}
2) Is your tree a binary search tree? Consider what happens in this case:
root-node
/ \
smallest largest
\
not-smallest
You should rehang not-smallest node instead of smallest.
3) Why do you free NULL?
(treePtr)->item = NULL;
free(treePtr->item);

Answer 2

You're deleting the smallest node without changing the child of its parent. If you delete a node, you should also change its parent to point to NULL. Note that setting treePtr->item to NULL doesn't accomplish this as treePtr->left points to a TreeNodePtr, not to its item member.

Answer 3

This function
static char* findMinimum(TreeNodePtr treePtr){
if(treePtr->left == NULL){
printf("Minimum node is %s\n", treePtr->item);
char * temp = treePtr->item;
(treePtr)->item = NULL;
free(treePtr->item);
return(temp);
}
else{
findMinimum(treePtr->left);
}
}
does not make sense.
For starters this part or the code
else{
findMinimum(treePtr->left);
}
returns nothing. So the function already have undefined behavior.
Also consider these statements
(treePtr)->item = NULL;
free(treePtr->item);
The call of free does nothing.
Otherwise if you will exchange the statements when the function returns a pointer to already deleted string. And again the progarm will have undefined behavior.
Also it is unclear how the function will behave when it will be called the second time when the smallest string was already deleted.
And you have to dynamically create a copy of the smallest string that will be returned from the function.
I would suggest the following function implementation (without testing).
static char * findMinimum( TreeNodePtr treePtr )
{
if ( treePtr == NULL || treePtr->item == NULL ) return NULL;
if ( treePtr->left == NULL || treePtr->left->item == NULL )
{
char *s = malloc( strlen( treePtr->item ) + 1 );
strcpy( s, treePtr->item );
free( treePtr->item );
treePtr->item = NULL;
return s;
}
else
{
return findMinimum( treePtr->left );
}
}