Find min and max element in a binary tree

// C program for 
// Find min and max element 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 and max node recursively
void findNode(struct TreeNode *node, 
              struct TreeNode **min, 
              struct TreeNode **max)
{
	if (node == NULL)
	{
		return;
	}
	if (( *min)->data > node->data)
	{
		// Change 
		*min = node;
	}
	if (( *max)->data < node->data)
	{
		*max = node;
	}
	// Visit left and right subtree
	findNode(node->left, min, max);
	findNode(node->right, min, max);
}
void minAndMax(struct TreeNode *root)
{
	if (root == NULL)
	{
		return;
	}
	// Assign first root of tree
	struct TreeNode *min = root;
	struct TreeNode *max = root;
	// Find node value
	findNode(root, & min, & max);
	// Display min and max node value
	printf(" Minimum : %d", min->data);
	printf("\n Maximum : %d\n", max->data);
	// Note that in case only one node then both 
	// printing the value of root node
}
int main(int argc, char
	const *argv[])
{
	struct BinaryTree *tree = newTree();
	/*
	             4                            
	           /   \    
	         -4     7    
	         / \     \               
	        2   3     12
	       /   / \    / 
	      1   10  8  15
	     /    /       \
	    3    9         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->right = newNode(8);
	tree->root->left->left = newNode(2);
	tree->root->left->left->left = newNode(1);
	tree->root->left->left->left->left = newNode(3);
	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);
	minAndMax(tree->root);
	return 0;
}

Output

 Minimum : -4
 Maximum : 15