Deepest left leaf node in a binary tree

/*
    C Program 
    Deepest left leaf node 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;
}
// Print tree elements
void preorder(struct TreeNode *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %d", node->data);
		preorder(node->left);
		preorder(node->right);
	}
}
// Finding the deepest left Leaf
void deepestLeftLeaf(struct TreeNode *node, int level, int *height, struct TreeNode **result)
{
	if (node == NULL)
	{
		return;
	}
	// Reversibly, visit left and right subtree
	deepestLeftLeaf(node->left, level + 1, height, result);
	deepestLeftLeaf(node->right, level + 1, height, result);
	if (node->left != NULL && node->left->left == NULL && node->left->right == NULL && level > *height)
	{
		// When getting new leaf deep leaf node
		*height = level;
		// Get node
		*result = node->left;
	}
}
// Handles the requests of finding a left deep leaf node
void findDeepestLLeaf(struct TreeNode *root)
{
	if (root == NULL)
	{
		printf("\n Empty Tree\n");
		return;
	}
	struct TreeNode *result = NULL;
	int height = -1;
	deepestLeftLeaf(root, 0, & height, & result);
	// Display tree elements
	printf("\n Tree Node : ");
	preorder(root);
	printf("\n Deepest left leaf Node is :");
	if (result != NULL)
	{
		// Display deepest node
		printf(" %d \n", result->data);
	}
	else
	{
		// When the leaf node is not present
		printf(" None \n");
	}
}
int main()
{
	// Define tree
	struct BinaryTree *tree1 = newTree();
	struct BinaryTree *tree2 = newTree();
	/*
	      1
	    /  \
	   /    \
	  2      8
	 / \    / \
	3  10  6   4
	   /  / \   
	  7  5   9
	   \        
	    11
	-----------------------
	   First Binary Tree
	-----------------------
	*/
	tree1->root = newNode(1);
	tree1->root->left = newNode(2);
	tree1->root->right = newNode(8);
	tree1->root->left->left = newNode(3);
	tree1->root->left->right = newNode(10);
	tree1->root->left->right->left = newNode(7);
	tree1->root->left->right->left->right = newNode(11);
	tree1->root->right->left = newNode(6);
	tree1->root->right->left->right = newNode(9);
	tree1->root->right->right = newNode(4);
	tree1->root->right->left->left = newNode(5);
	findDeepestLLeaf(tree1->root);
	/*
	      1
	    /  \
	   /    \
	  2      8
	   \    / \
	   10  6   4
	   /    \   
	  7      9
	   \        
	    11
	-----------------------
	   Second Binary Tree
	-----------------------
	*/
	tree2->root = newNode(1);
	tree2->root->left = newNode(2);
	tree2->root->right = newNode(8);
	tree2->root->left->right = newNode(10);
	tree2->root->left->right->left = newNode(7);
	tree2->root->left->right->left->right = newNode(11);
	tree2->root->right->left = newNode(6);
	tree2->root->right->left->right = newNode(9);
	tree2->root->right->right = newNode(4);
	findDeepestLLeaf(tree2->root);
	return 0;
}

Output

 Tree Node :   1  2  3  10  7  11  8  6  5  9  4
 Deepest left leaf Node is : 5

 Tree Node :   1  2  10  7  11  8  6  9  4
 Deepest left leaf Node is : None