Print top view of a binary tree using level order traversal

/*
    C Program 
    Print top view of a binary tree using level order traversal
*/
#include <stdio.h>
#include <stdlib.h>

// Queue node
struct QueueNode
{
	struct TreeNode *element;
	struct QueueNode *next;
	int distance;
};
// Define queue
struct MyQueue
{
	struct QueueNode *front;
	struct QueueNode *tail;
};
// Binary Tree node
struct TreeNode
{
	int data;
	struct TreeNode *left, *right;
};
struct BinaryTree
{
	struct TreeNode *root;
};
struct MyQueue *makeQueue()
{
	// Create dynamic node of MyQueue
	struct MyQueue *node = (struct MyQueue *) malloc(sizeof(struct MyQueue));
	if (node == NULL)
	{
		printf("\n Memory Overflow, when creating a new Queue\n");
	}
	else
	{
		node->front = NULL;
		node->tail = NULL;
	}
	return node;
}
// 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;
}
struct BinaryTree *makeTree()
{
	// Create dynamic node of BinaryTree
	struct BinaryTree *node = (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
	if (node == NULL)
	{
		printf("\nMemory Overflow, when creating a new BinaryTree\n");
	}
	else
	{
		node->root = NULL;
	}
	return node;
}
int isEmpty(struct MyQueue *queue)
{
	if (queue == NULL || queue->front == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
// Create a queue node and returns this node
void enqueue(struct MyQueue *queue, struct TreeNode *element, int distance)
{
	// Make a new Queue node
	struct QueueNode *node = (struct QueueNode *) malloc(sizeof(struct QueueNode));
	if (node != NULL)
	{
		// Set node values
		node->element = element;
		node->next = NULL;
		node->distance = distance;
		if (queue->front == NULL)
		{
			queue->front = node;
			queue->tail = queue->front;
		}
		else
		{
			queue->tail->next = node;
			queue->tail = node;
		}
	}
	else
	{
		printf("\nMemory Overflow, when creating a new Queue Node\n");
	}
}
//Remove a queue elements
void dequeue(struct MyQueue *queue)
{
	if (isEmpty(queue) == 0)
	{
		struct QueueNode *remove = queue->front;
		if (queue->front == queue->tail)
		{
			queue->tail = NULL;
		}
		queue->front = queue->front->next;
		remove->element = NULL;
		remove->next = NULL;
		//free node
		free(remove);
		remove = NULL;
	}
}
// Return front element of queue
struct QueueNode *peek(struct MyQueue *queue)
{
	if (isEmpty(queue) == 1)
	{
		return NULL;
	}
	else
	{
		return queue->front;
	}
}
// Display top view of binary tree using level order traversal
void printTopView(struct TreeNode *root)
{
	if (root == NULL)
	{
		return;
	}
	else
	{
		struct MyQueue *q = makeQueue();
		// min and max decide boundary of top view
		int min = 0;
		int max = 0;
		int distance = 0;
		// Add first element
		enqueue(q, root, 0);
		struct TreeNode *node = root;
		// root node of tree is always part of top view
		printf("\n Level order Top view of binary tree \n %d", root->data);
		while (node != NULL)
		{
			// Get node distance
			distance = peek(q)->distance;
			if (node->left != NULL)
			{
				if (min > distance - 1)
				{
					min = distance - 1;
					// Displaying the result top view node
					printf(" %d", node->left->data);
				}
				enqueue(q, node->left, distance - 1);
			}
			if (node->right != NULL)
			{
				if (max < distance + 1)
				{
					max = distance + 1;
					// Displaying the result top view node
					printf(" %d", node->right->data);
				}
				enqueue(q, node->right, distance + 1);
			}
			// Remove queue element
			dequeue(q);
			if (isEmpty(q) == 1)
			{
				node = NULL;
			}
			else
			{
				// Get tree node
				node = peek(q)->element;
			}
		}
		printf("\n");
	}
}
int main(int argc, char
	const *argv[])
{
	// Define tree
	struct BinaryTree *tree = makeTree();
	/*
	          1
	        /   \
	       2     3
	     /   \    \ 
	    4     5    11
	   / \   / \
	  6   7 8   9
	             \
	              10
	                \
	                 15                           
	-----------------------
	    Binary Tree
	-----------------------
	*/
	tree->root = newNode(1);
	tree->root->left = newNode(2);
	tree->root->right = newNode(3);
	tree->root->left->left = newNode(4);
	tree->root->left->right = newNode(5);
	tree->root->left->left->left = newNode(6);
	tree->root->left->left->right = newNode(7);
	tree->root->left->right->left = newNode(8);
	tree->root->left->right->right = newNode(9);
	tree->root->left->right->right->right = newNode(10);
	tree->root->right->right = newNode(11);
	tree->root->left->right->right->right->right = newNode(15);
	printTopView(tree->root);
	return 0;
}

Output

 Level order Top view of binary tree
 1 2 3 4 11 6 15