Max average of subtree values in a given binary tree

// C program for 
// Max average of subtree values in a given 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;
}
double maxValue(double a, double b)
{
	if (a > b)
	{
		return a;
	}
	return b;
}
int findMaxAverage(struct TreeNode *node, double *average, int *count)
{
	if (node == NULL)
	{
		return 0;
	}
	int leftSubTree = 0;
	int rightSubTree = 0;
	// Sum of left and right sub tree
	int lSum = findMaxAverage(node->left, average, & leftSubTree);
	int rSum = findMaxAverage(node->right, average, & rightSubTree);
	// Calculate sum of subtree nodes
	int sum = lSum + rSum + node->data;
  	*count = leftSubTree + rightSubTree + 1;
	// Display calculated operation
	printf("\n Node : %d  + [left subtree sum : %d + right subtree sum : %d ] ",
           node->data, lSum, rSum);
	printf("\n Total Node : %d ", *count);
	printf("\n Average : (%d/%d) = %lf \n", 
           sum, *count , (double) sum / *count);
	if ( *count == 0)
	{
		*average = maxValue( *average, (double) sum);
	}
	else
	{
		*average = maxValue( *average, (double) sum / *count);
	}
	return sum;
}
// Handles the request to find average of max subtree
void maxAverage(struct TreeNode *root)
{
	if (root == NULL)
	{
		return;
	}
	double average = 0.0;
	int count = 0;
	findMaxAverage(root, & average, & count);
	// Display final result
	printf("\n Result : %lf ", average);
}
int main(int argc, char
	const *argv[])
{
	struct BinaryTree *tree = newTree();
	/*
	             4                            
	           /   \    
	         -4     7    
	         / \     \               
	        2   30    12
	       /   / \    / 
	      19  15  18 15
	    -----------------
	       Binary tree

	*/
	tree->root = newNode(4);
	tree->root->left = newNode(-4);
	tree->root->right = newNode(7);
	tree->root->right->right = newNode(12);
	tree->root->right->right->left = newNode(15);
	tree->root->left->right = newNode(30);
	tree->root->left->right->right = newNode(18);
	tree->root->left->right->left = newNode(15);
	tree->root->left->left = newNode(2);
	tree->root->left->left->left = newNode(19);
	// Max subtree
	// [30+15+18] / 3 = (63 /3 ) = 21
  	// Here 3 indicates number of nodes
	maxAverage(tree->root);
	return 0;
}

Output

 Node : 19  + [left subtree sum : 0 + right subtree sum : 0 ]
 Total Node : 1
 Average : (19/1) = 19.000000

 Node : 2  + [left subtree sum : 19 + right subtree sum : 0 ]
 Total Node : 2
 Average : (21/2) = 10.500000

 Node : 15  + [left subtree sum : 0 + right subtree sum : 0 ]
 Total Node : 1
 Average : (15/1) = 15.000000

 Node : 18  + [left subtree sum : 0 + right subtree sum : 0 ]
 Total Node : 1
 Average : (18/1) = 18.000000

 Node : 30  + [left subtree sum : 15 + right subtree sum : 18 ]
 Total Node : 3
 Average : (63/3) = 21.000000

 Node : -4  + [left subtree sum : 21 + right subtree sum : 63 ]
 Total Node : 6
 Average : (80/6) = 13.333333

 Node : 15  + [left subtree sum : 0 + right subtree sum : 0 ]
 Total Node : 1
 Average : (15/1) = 15.000000

 Node : 12  + [left subtree sum : 15 + right subtree sum : 0 ]
 Total Node : 2
 Average : (27/2) = 13.500000

 Node : 7  + [left subtree sum : 0 + right subtree sum : 27 ]
 Total Node : 3
 Average : (34/3) = 11.333333

 Node : 4  + [left subtree sum : 80 + right subtree sum : 34 ]
 Total Node : 10
 Average : (118/10) = 11.800000

 Result : 21.000000