Print all nodes between the given two levels of a binary tree

// C program
// Print all nodes between the given two levels of a binary 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;
	}
}
//This are printing all binary tree nodes, between given (A to B) levels
void print_level_nodes(struct Node *root, int a, int b)
{
	if (a <= 0 || b <= 0)
	{
		//invalid level
		return;
	}
	if (a > b)
	{
		//When level sequence in not valid
		//Then change its sequence
		print_level_nodes(root, b, a);
	}
	else
	{
		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;
			printf("\n Node between level (%d-%d) is \n", a, b);
			// Define a tree variable
			struct Node *node = NULL;
			// Result indicator
			int status = 0;
			// 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 >= a && front->level <= b)
				{
					printf(" %d", node->data);
					status = 1;
				}
				dequeue( &front);
			}
			tail = NULL;
			if (status == 0)
			{
				printf(" None");
			}
		}
		else
		{
			printf("\nEmpty Tree\n");
		}
	}
}
int main()
{
	struct Node *root = NULL;
	/*
	Construct Binary Tree
	-----------------------
	       10
	     /   \
	    2     3
	   /     / \
	  4     9   5
	 /  \    \    \
	7    3    6   20
	    /  \     /
	   2    8   -3
	         \    
	          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(20);
	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->right = insert(9);
	print_level_nodes(root, 2, 4);
	print_level_nodes(root, 4, 6);
	print_level_nodes(root, 1, 3);
	print_level_nodes(root, 7, 8);
	return 0;
}

Output

 Node between level (2-4) is
 2 3 4 9 5 7 3 6 20
 Node between level (4-6) is
 7 3 6 20 2 8 -3 9
 Node between level (1-3) is
 10 2 3 4 9 5
 Node between level (7-8) is
 None