Find the minimum leaf node in a binary tree

// C program for 
// Find the minimum leaf node in a binary tree
#include <stdio.h>
#include <stdlib.h>

// Tree Node
struct TreeNode
{
	int data;
	struct TreeNode *left;
	struct TreeNode *right;
};
// Binary Tree
struct BinaryTree
{
	struct TreeNode *root;
};
// Create new tree
struct BinaryTree *newTree()
{
	// Create dynamic node
	struct BinaryTree *tree = 
      (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
	if (tree != NULL)
	{
		tree->root = NULL;
	}
	else
	{
		printf("Memory Overflow to Create tree Tree\n");
	}
	//return new tree
	return tree;
}
// This is creates and returns the new binary tree node
struct TreeNode *newNode(int data)
{
	// Create dynamic node
	struct TreeNode *new_node = 
      (struct TreeNode *) malloc(sizeof(struct TreeNode));
	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;
}
// Find the value of min leaf node recursively
void findMinLeaf(struct TreeNode *node, struct TreeNode **result)
{
	if (node == NULL)
	{
		return;
	}
	if (node->left == NULL && node->right == NULL)
	{
		if ( *result == NULL)
		{
			// First leaf node
			*result = node;
		}
		else if (( *result)->data > node->data)
		{
			*result = node;
		}
	}
	// Visit left and right subtree
	findMinLeaf(node->left, result);
	findMinLeaf(node->right, result);
}
// Handles the request of finding the minimum leaf node in binary tree.
void minLeafNode(struct TreeNode *root)
{
	if (root == NULL)
	{
		return;
	}
	struct TreeNode *result = NULL;
	// Find node value
	findMinLeaf(root, & result);
	if (result != NULL)
	{
		printf(" Minimum leaf node value is : %d\n", result->data);
	}
	else
	{
		printf(" Minimum left is : None \n");
	}
}
int main(int argc, char
	const *argv[])
{
	struct BinaryTree *tree = newTree();
	/*
	             4                            
	           /   \    
	         -4     7    
	         / \     \               
	        2   3     12
	       /   / \    / 
	      1   10  8  15
	     /    / \     \
	    31   9   21    13 

	    -----------------
	       Binary tree

	*/
	tree->root = newNode(4);
	tree->root->left = newNode(-4);
	tree->root->left->right = newNode(3);
	tree->root->left->right->left = newNode(10);
	tree->root->left->right->left->left = newNode(9);
	tree->root->left->right->left->right = newNode(21);
	tree->root->left->right->right = newNode(8);
	tree->root->left->left = newNode(2);
	tree->root->left->left->left = newNode(1);
	tree->root->left->left->left->left = newNode(31);
	tree->root->right = newNode(7);
	tree->root->right->right = newNode(12);
	tree->root->right->right->left = newNode(15);
	tree->root->right->right->left->right = newNode(13);
	minLeafNode(tree->root);
	return 0;
}

Output

 Minimum leaf node value is : 8