Convert binary tree into min max product

/*
    C Program 
    Convert binary tree into min max product
*/
#include <stdio.h>

#include <stdlib.h>

//Binary Tree node
struct Node
{
	int data;
	struct Node *left, *right;
};
struct Collector
{
	int min;
	int max;
};
//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 preorder(struct Node *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %d", node->data);
		preorder(node->left);
		preorder(node->right);
	}
}
// Returns a maximum value of given two numbers
int big(int a, int b)
{
	if (a > b)
	{
		return a;
	}
	else
	{
		return b;
	}
}
// Returns a minimum value of given two numbers
int small(int a, int b)
{
	if (a < b)
	{
		return a;
	}
	else
	{
		return b;
	}
}
//Replace the given binary tree nodes with its min-max product
struct Collector *min_max_product(struct Node *node)
{
	if (node != NULL)
	{
		// Get current node data
		int element = node->data;
		struct Collector *info = (struct Collector *) malloc(sizeof(struct Collector));
		if (node->left == NULL && node->right == NULL)
		{
			//When leaf node 
			info->max = element;
			info->min = element;
			return info;
		}
		struct Collector *left = min_max_product(node->left);
		struct Collector *right = min_max_product(node->right);
		if (node->left != NULL && node->right != NULL)
		{
			// When node have left and right subtree 
			// Change node value
			node->data = small(left->min, right->min) * big(right->max, left->max);
			// Update new min and max value
			info->min = small(left->min, small(right->min, element));
			info->max = big(left->max, big(right->max, element));
		}
		else if (node->right != NULL)
		{
			// When node have right subtree
			// Change node value
			node->data = right->min * right->max;
			// Update new min and max value
			info->min = small(right->min, element);
			info->max = big(right->max, element);
		}
		else
		{
			// When node have left subtree
			// Change node value
			node->data = left->min * left->max;
			// Update new min and max value
			info->min = small(left->min, element);
			info->max = big(left->max, element);
		}
		return info;
	}
	return NULL;
}
int main()
{
	struct Node *root = NULL;
	/*     
	        8
	      /   \
	     4     9
	    / \   /  \
	   7   3 5    2
	      /   \
	     6     7
	*/
	root = add_node(8);
	root->left = add_node(4);
	root->left->right = add_node(3);
	root->left->left = add_node(7);
	root->right = add_node(9);
	root->right->left = add_node(5);
	root->right->right = add_node(2);
	root->left->right->left = add_node(6);
	root->right->left->right = add_node(7);
	//Display Tree elements
	printf("\n Before \n");
	preorder(root);
	min_max_product(root);
	printf("\n After \n");
	preorder(root);
	return 0;
}

Output

 Before
  8  4  7  3  6  9  5  7  2
 After
  18  21  7  36  6  14  49  7  2