Reverse alternate levels of a binary tree

// C program
// Reverse alternate 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;
	}
}
//Reverse level nodes
void reverse_level(struct MyQueue *front, int level)
{
	if (front == NULL)
	{
		return;
	}
	int size = 0;
	struct MyQueue *temp = front;
	//Count number of nodes in given level
	while (temp != NULL && temp->level == level)
	{
		size++;
		temp = temp->next;
	}
	if (size == 1)
	{
		//When only one element in given level
		return;
	}
	else
	{
		//Useful for storing level values
		int collection[size];
		int location = 0;
		//Start to first node
		temp = front;
		//Get level nodes from left to right
		while (temp != NULL && temp->level == level)
		{
			// Get node value
			collection[location] = temp->element->data;
			temp = temp->next;
			// Change location
			location++;
		}
		location = size - 1;
		//Start to first node
		temp = front;
		// Update level node with its reverse order node value
		while (location >= 0 && temp != NULL && temp->level == level)
		{
			temp->element->data = collection[location];
			temp = temp->next;
			location--;
		}
	}
}
// Travers the level order nodes in binary tree and 
// Display alternate reversal level nodes
void reverse_alternate_level(struct Node *root)
{
	if (root != NULL)
	{
		//make queue pointers
		struct MyQueue *front = NULL, *tail = NULL;
		struct MyQueue *temp = NULL;
		//make a tree pointer
		struct Node *node = 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;
		// Start to first node
		temp = front;
		int level = 0;
		// Get level elements into a queue
		while (temp != NULL)
		{
			//Tree node
			node = temp->element;
			//Get node level
			level = temp->level + 1;
			if (node->left != NULL)
			{
				//Add new left child node
				tail->next = enqueue(node->left);
				tail->next->level = level;
				tail = tail->next;
			}
			if (node->right != NULL)
			{
				//Add new right child node
				tail->next = enqueue(node->right);
				tail->next->level = level;
				tail = tail->next;
			}
			//Visit to next node queue
			temp = temp->next;
		}
		//Print level nodes, and reverse alternate level elements
		while (front != NULL)
		{
			// Get node level
			level = front->level;
			printf(" [");
			if (level % 2 == 0)
			{
				//This reverse level 
				reverse_level(front, level);
			}
			//Print and removing queue nodes
			while (front != NULL && front->level == level)
			{
				printf(" %d ", front->element->data);
				//remove  a queue node
				dequeue( &front);
			}
			printf("]\n");
		}
		tail = NULL;
	}
	else
	{
		printf("Empty Tree\n");
	}
}
int main()
{
	struct Node *root = NULL;
	/*
	Construct Binary Tree
	-----------------------
	            7
	          /    \
	         /      \
	        3        4
	       /      /    \
	      2      6      8
	     /  \     \    / 
	    1    5     7  10
	        / \     \
	       9   3     11
	-- -- -- -- -- -- -- -- -- -- -- - 
    */
	//Add node
	root = insert(7);
	root->left = insert(3);
	root->right = insert(4);
	root->right->right = insert(8);
	root->right->left = insert(6);
	root->left->left = insert(2);
	root->left->left->left = insert(1);
	root->left->left->right = insert(5);
	root->right->left->right = insert(7);
	root->right->right->left = insert(10);
	root->left->left->right->left = insert(9);
	root->left->left->right->right = insert(3);
	root->right->left->right->right = insert(11);
	/*
	Converted Binary tree
	-----------------------
	            7
	          /    \
	         /      \
	        4        3   // change level
	       /      /    \
	      2      6      8
	     /  \     \    /
	    10   7     5  1   // change level
	        / \     \
	       9   3     11
	-- -- -- -- -- -- -- -- -- -- -- - */
	reverse_alternate_level(root);
	return 0;
}

Output

 [ 7 ]
 [ 4  3 ]
 [ 2  6  8 ]
 [ 10  7  5  1 ]
 [ 9  3  11 ]