Print the nodes at odd levels of a tree

// C program
// Print the nodes at odd levels of a tree 
#include <stdio.h>

#include <stdlib.h>

//Node of binary tree
struct Node
{
	int data;
	struct Node * left, * right;
};
struct MyQueue
{
	int level;
	struct Node * element;
	struct MyQueue * next;
};
//Create a binary tree nodes and node fields (data,pointer) 
//And returning the reference of newly nodes
struct Node * insert(int data)
{
	//create dynamic memory to new binary tree node
	struct Node * new_node = (struct Node * ) malloc(sizeof(struct Node));
	if (new_node != NULL)
	{
		//Set node value
		new_node->data = data;
		new_node->left = NULL;
		new_node->right = NULL;
	}
	else
	{
		printf("Memory Overflow\n");
	}
	//return reference
	return new_node;
}
//Create a queue node and returns this node
struct MyQueue * enqueue(struct Node * tree_node)
{
	//Make a new Queue node
	struct MyQueue * new_node = (struct MyQueue * ) malloc(sizeof(struct MyQueue));
	if (new_node != NULL)
	{
		//Set node values
		new_node->element = tree_node;
		new_node->next = NULL;
	}
	else
	{
		printf("Memory Overflow\n");
	}
	return new_node;
}
//Remove a queue elements
void dequeue(struct MyQueue ** front)
{
	if ( * front != NULL)
	{
		struct MyQueue * remove = * front;
		//Visit to next node
		* front = remove->next;
		remove->element = NULL;
		remove->next = NULL;
		//free node
		free(remove);
		remove = NULL;
	}
}
//print all odd level nodes in binary tree
void odd_level_nodes(struct Node * root)
{
	if (root != NULL)
	{
		//make a queue pointers
		struct MyQueue * front = NULL, * tail = NULL;
		//Get first node of tree
		front = enqueue(root);
		//Start level of first node is one
		front->level = 1;
		//Set tail node to first node
		tail = front;
		// Define a tree variable
		struct Node * node = NULL;
		printf(" Odd Level Nodes \n");
		// Traversal tree elements in level order
		while (front != NULL)
		{
			// Tree node
			node = front->element;
			if (node->left != NULL)
			{
				// Add new left child node
				tail->next = enqueue(node->left);
				tail->next->level = front->level + 1;
				tail = tail->next;
			}
			if (node->right != NULL)
			{
				// Add new right child node
				tail->next = enqueue(node->right);
				tail->next->level = front->level + 1;
				tail = tail->next;
			}
			if (front->level % 2 != 0)
			{
				// When get odd level node
				printf(" %d", node->data);
			}
			dequeue( & front);
		}
		printf("\n");
		tail = NULL;
	}
	else
	{
		printf("\nEmpty Tree\n");
	}
}
int main()
{
	struct Node * root = NULL;
	/*  
	Construct Binary Tree
	-----------------------
	           10
	         /   \
	        2     3
	       /     / \
	      4     9   5
	     /  \    \    \
	    7    3    6   11
	        /  \     /
	       2    8   -3
	           / \    
	         -1   9

	-----------------------
	*/
	//Add node
	root = insert(10);
	root->left = insert(2);
	root->right = insert(3);
	root->right->right = insert(5);
	root->right->left = insert(9);
	root->left->left = insert(4);
	root->left->left->left = insert(7);
	root->left->left->right = insert(3);
	root->right->left->right = insert(6);
	root->right->right->right = insert(11);
	root->right->right->right->left = insert(-3);
	root->left->left->right->left = insert(2);
	root->left->left->right->right = insert(8);
	root->left->left->right->right->left = insert(-1);
	root->left->left->right->right->right = insert(9);
	odd_level_nodes(root);
	return 0;
}

Output

 Odd Level Nodes
 10 4 9 5 2 8 -3