Maximum path sum from leaf to leaf

/*
    C Program 
    Maximum path sum from leaf to leaf
*/
#include <stdio.h>
#include <limits.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 *new_tree()
{
	// 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;
}
// returns a new node of tree
struct TreeNode *new_node(int data)
{
	// Create dynamic node
	struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
	if (node != NULL)
	{
		//Set data and pointer values
		node->data = data;
		node->left = NULL;
		node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return node;
}
// Find maximum path between two leaf nodes
int leafPath(struct TreeNode *node, int *max)
{
	if (node != NULL)
	{
		if (node->left == NULL && node->right == NULL)
		{
			return node->data;
		}
		// Through by recursion find leaf path of left and right subtree
		int a = leafPath(node->left, max) + node->data;
		int b = leafPath(node->right, max) + node->data;
		if ( *max < ((a + b) - node->data))
		{
			// When current node left and right subtree contains max sum leaf path
			*max = ((a + b) - node->data);
		}
		if (a > b)
		{
			// Select path of left subtree
			if ( *max < a)
			{
				*max = a;
			}
			return a;
		}
		else
		{
			// Select path of right subtree
			if ( *max < b)
			{
				*max = b;
			}
			return b;
		}
	}
	return 0;
}
// Handles the request to find sum of maximum path between two leaf nodes
void maxleafPath(struct TreeNode *root)
{
	if (root != NULL)
	{
		if (root->left != NULL && root->right != NULL)
		{
			// When two leaf nodes exist in given tree
			int max = INT_MIN;
			leafPath(root, & max);
			printf("\n Result : %d \n", max);
		}
		else
		{
			// Find internal nodes that have two children?
			struct TreeNode *node = NULL;
			// Choose a valid direction
			if (root->left != NULL)
			{
				node = root->left;
			}
			else
			{
				node = root->right;
			}
			// Find nodes that have two childrenThis
			while (node != NULL && (node->left == NULL || node->right == NULL))
			{
				if (node->left == NULL)
				{
					node = node->right;
				}
				else
				{
					node = node->left;
				}
			}
			if (node != NULL && node->left != NULL && node->right != NULL)
			{
				maxleafPath(node);
			}
			else
			{
				printf("\n Two leaf nodes are not exist \n");
			}
		}
	}
}
//Display pre order elements
void preorder(struct TreeNode *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %d", node->data);
		preorder(node->left);
		preorder(node->right);
	}
}
int main()
{
	// Define trees
	struct BinaryTree *tree1 = new_tree();
	struct BinaryTree *tree2 = new_tree();
	struct BinaryTree *tree3 = new_tree();
	/*
	         1
	       /   \
	      2     3
	     / \   / \
	    3   4 6   5
	       /   \   \
	     -7     4   2
	           / \
	          1  -2  
	-----------------------
	    Binary Tree
	-----------------------
	*/
	tree1->root = new_node(1);
	tree1->root->left = new_node(2);
	tree1->root->right = new_node(3);
	tree1->root->left->left = new_node(3);
	tree1->root->left->right = new_node(4);
	tree1->root->left->right->left = new_node(-7);
	tree1->root->right->left = new_node(6);
	tree1->root->right->right = new_node(5);
	tree1->root->right->left->right = new_node(4);
	tree1->root->right->right->right = new_node(2);
	tree1->root->right->left->right->left = new_node(1);
	tree1->root->right->left->right->right = new_node(-2);
	preorder(tree1->root);
	maxleafPath(tree1->root);
	/*
	         1
	       /   \
	      2     3
	     / \   / \
	    4   5 8   7
	-----------------------
	    Binary Tree
	-----------------------
	*/
	tree2->root = new_node(1);
	tree2->root->left = new_node(2);
	tree2->root->left->left = new_node(4);
	tree2->root->left->right = new_node(5);
	tree2->root->right = new_node(3);
	tree2->root->right->left = new_node(8);
	tree2->root->right->right = new_node(7);
	preorder(tree2->root);
	maxleafPath(tree2->root);
	/*
	        1
	       /   
	      2     
	     / 
	    4   
	-----------------------
	    Binary Tree
	-----------------------
	*/
	tree3->root = new_node(1);
	tree3->root->left = new_node(2);
	tree3->root->left->left = new_node(3);
	preorder(tree3->root);
	maxleafPath(tree3->root);
	return 0;
}

Output

  1  2  3  4  -7  3  6  4  1  -2  5  2
 Result : 21
  1  2  4  5  3  8  7
 Result : 19
  1  2  3
 Two leaf nodes are not exist