Longest zig zag path in a binary tree

/*
    C Program 
    Longest zig zag path 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;
}
// returns a new node of tree
struct TreeNode *newNode(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;
}
// Returns the max of given two numbers
int maxValue(int l, int r)
{
	if (l > r)
	{
		return l;
	}
	else
	{
		return r;
	}
}
// Find zigzag Path
int zigzagPath(struct TreeNode *node, int *result, int direction)
{
	if (node == NULL)
	{
		return -1;
	}
	else if (node->left == NULL && node->right == NULL)
	{
		return 0;
	}
	// Recursively visit left and right subtree
	int l = zigzagPath(node->left, result, 1) + 1;
	int r = zigzagPath(node->right, result, 0) + 1;
	// Calculate zigzag sequence
	*result = maxValue( *result, maxValue(l, r));
	if (direction == 1)
	{
		// Take the result of right subtree
		return r;
	}
	else
	{
		// Take the result of left subtree
		return l;
	}
}
// Handles the request of find longest pattern of zigzag
void longestZigzag(struct TreeNode *root)
{
	int result = 0;
	if (root != NULL)
	{
		// We consider the sequence
		// 1) left right left ...
		// 2) right left right ...
		zigzagPath(root, & result, 0);
		zigzagPath(root, & result, 1);
	}
	if (result == 0)
	{
		printf(" None \n");
	}
	else
	{
		printf(" Longest zigzag : %d \n", result);
	}
}
int main()
{
	// Define trees
	struct BinaryTree *tree = newTree();
	/*
	         1
	       /   \
	      2     3
	     / \   / \
	    3   4 6   5
	       /   \   \
	     -7     4   2
	     /     / \
	    9     1  -2  
	         /
	        7 
	         \
	          10
	-----------------------
	    Binary Tree
	-----------------------
	*/
	tree->root = newNode(1);
	tree->root->left = newNode(2);
	tree->root->right = newNode(3);
	tree->root->left->left = newNode(3);
	tree->root->left->right = newNode(4);
	tree->root->left->right->left = newNode(-7);
	tree->root->left->right->left->left = newNode(9);
	tree->root->right->left = newNode(6);
	tree->root->right->right = newNode(5);
	tree->root->right->left->right = newNode(4);
	tree->root->right->right->right = newNode(2);
	tree->root->right->left->right->left = newNode(1);
	tree->root->right->left->right->right = newNode(-2);
	tree->root->right->left->right->left->left = newNode(7);
	tree->root->right->left->right->left->left->right = newNode(10);
	longestZigzag(tree->root);
	return 0;
}

Output

 Longest zigzag : 4