Delete leaf node with given value

/*
  C Program  
  Delete leaf node with given value
*/
#include <stdio.h>

#include <stdlib.h>

//Binary Tree node
struct Node
{
	int data;
	struct Node *left, *right;
};
//This is creating a binary tree node and return this
struct Node *add_node(int data)
{
	// Create dynamic node
	struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
	if (new_node != NULL)
	{
		//Set data and pointer values
		new_node->data = data;
		new_node->left = NULL;
		new_node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return new_node;
}
//Recursive function
//Display preorder view of binary tree
void pre_order(struct Node *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %d", node->data);
		pre_order(node->left);
		pre_order(node->right);
	}
}
//Recursively process, deleting leaf nodes which equal to given key
struct Node *delete_leaf_key(struct Node *node, int key, int *status)
{
	if (node != NULL)
	{
		//Recursive execute, left and right subtree
		node->left = delete_leaf_key(node->left, key, status);
		node->right = delete_leaf_key(node->right, key, status);
		if (node->left == NULL && node->right == NULL && node->data == key)
		{
			//When get a deleted leaf node
			*status = 1;
			free(node);
			node = NULL;
			//This is deleted leaf node
			return NULL;
		}
		return node;
	}
	else
	{
		return NULL;
	}
}
//This is used to handle the request of delete leaf nodes by given key
struct Node *delete_node(struct Node *root, int key)
{
	if (root == NULL)
	{
		printf("\nEmpty Tree\n");
		return NULL;
	}
	else
	{
		// Before delete, display tree elements
		printf("\n  Before delete leaf key %d is ", key);
		printf("\n  Tree Element \n");
		pre_order(root);
		// Use to detect
		int status = 0;
		// Delete leaf nodes
		root = delete_leaf_key(root, key, &status);
		if (status == 1)
		{
			//When delete key is exist in leaves position
			printf("\n  After delete leaf key %d is ", key);
			printf("\n  Tree Element \n");
			pre_order(root);
			printf("\n");
		}
		else
		{
			// When deleted node not exist in leaves position 
			printf("\n  Leaf key %d not exist\n", key);
		}
		return root;
	}
}
int main()
{
	struct Node *root = NULL;
	/*
	Construct Binary Tree
	-----------------------
	      10
	     /   \
	    6     8
	   / \   / \
	  2   3 7   2
	 /       \   \
	9        -1   9
	*/
	//Add nodes
	root = add_node(10);
	root->left = add_node(6);
	root->left->left = add_node(2);
	root->right = add_node(8);
	root->right->right = add_node(2);
	root->right->left = add_node(7);
	root->left->left->left = add_node(9);
	root->right->left->right = add_node(-1);
	root->left->right = add_node(3);
	root->right->right->right = add_node(9);
	//Test execution
	root = delete_node(root, 9);
	root = delete_node(root, 2);
	root = delete_node(root, -1);
	return 0;
}

Output

  Before delete leaf key 9 is
  Tree Element
  10  6  2  9  3  8  7  -1  2  9
  After delete leaf key 9 is
  Tree Element
  10  6  2  3  8  7  -1  2

  Before delete leaf key 2 is
  Tree Element
  10  6  2  3  8  7  -1  2
  After delete leaf key 2 is
  Tree Element
  10  6  3  8  7  -1

  Before delete leaf key -1 is
  Tree Element
  10  6  3  8  7  -1
  After delete leaf key -1 is
  Tree Element
  10  6  3  8  7