Delete entire nodes of a binary tree

/*
  C Program  
  Delete entire nodes of a binary tree
  Using queue
*/
#include <stdio.h>

#include <stdlib.h>

//Binary Tree node
struct Node
{
	int data;
	struct Node *left, *right;
};
//Define Custom queue
struct MyQueue
{
	struct Node *element;
	struct MyQueue *next;
};
//This is creating a binary tree node and return this
struct Node *add_node(int data)
{
	// Create dynamic node
	struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
	if (new_node != NULL)
	{
		//Set data and pointer values
		new_node->data = data;
		new_node->left = NULL;
		new_node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return new_node;
}
//Recursive function
//Display preorder view of binary tree
void pre_order(struct Node *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %d", node->data);
		pre_order(node->left);
		pre_order(node->right);
	}
}
//Create a MyQueue element and return this reference
struct MyQueue *queue_node(struct Node *tree_node)
{
	struct MyQueue *MyQueue_node = (struct MyQueue *) malloc(sizeof(struct MyQueue));
	if (MyQueue_node != NULL)
	{
		//set pointer values
		MyQueue_node->element = tree_node;
		MyQueue_node->next = NULL;
	}
	else
	{
		printf("Memory Overflow\n");
		exit(0); //Terminate program execution
	}
	return MyQueue_node;
}
//Remove a MyQueue elements
void dequeue(struct MyQueue **head)
{
	if ( *head != NULL)
	{
		//Get a deleted node
		struct MyQueue *remove = *head;
		//Visit to next node of MyQueue
		*head = remove->next;
		//unlink tree element
		remove->element = NULL;
		//unlink next node
		remove->next = NULL;
		//free node
		free(remove);
		remove = NULL;
	}
}
// Deleting all nodes in given tree in from top to bottom direction level by level
// Using queue
struct Node *delete_all_nodes(struct Node *root)
{
	if (root == NULL)
	{
		printf("\nEmpty Tree\n");
		return NULL;
	}
	else
	{
		// Before delete, display tree elements
		printf("\n  Tree Element \n");
		pre_order(root);
		//Make MyQueue variables
		struct MyQueue *head = NULL;
		struct MyQueue *tail = NULL;
		//Get first node of tree
		struct Node *auxiliary = root;
		//Add first node into MyQueue
		head = queue_node(root);
		//initial tail is same to head of queue
		tail = head;
		//iterate the MyQueue elements
		while (head != NULL)
		{
			//Get current head element of MyQueue
			auxiliary = head->element;
			if (auxiliary->left != NULL)
			{
				//Add new left child node
				tail->next = queue_node(auxiliary->left);
				tail = tail->next;
			}
			if (auxiliary->right != NULL)
			{
				//Add new right child node
				tail->next = queue_node(auxiliary->right);
				tail = tail->next;
			}
			//Unlink left subtree
			auxiliary->left = NULL;
			//Remove element of MyQueue
			head->element = NULL;
			dequeue( &head);
			printf("\n Delete Node : %d", auxiliary->data);
			//Deleted tree element
			auxiliary->left = NULL;
			auxiliary->right = NULL;
			free(auxiliary);
			auxiliary = NULL;
		}
		tail = NULL;
		return NULL;
	}
}
int main()
{
	struct Node *root = NULL;
	/*
	Construct Binary Tree
	-----------------------
	      10
	     /   \
	    6     8
	   /     / \
	  2     7   2
	 /       \   \
	9        -1   9
	*/
	//Add nodes
	root = add_node(10);
	root->left = add_node(6);
	root->left->left = add_node(2);
	root->right = add_node(8);
	root->right->right = add_node(2);
	root->right->left = add_node(7);
	root->left->left->left = add_node(9);
	root->right->left->right = add_node(-1);
	root->right->right->right = add_node(9);
	//Test Process  
	root = delete_all_nodes(root);
	return 0;
}

Output

  Tree Element
  10  6  2  9  8  7  -1  2  9
 Delete Node : 10
 Delete Node : 6
 Delete Node : 8
 Delete Node : 2
 Delete Node : 7
 Delete Node : 2
 Delete Node : 9
 Delete Node : -1
 Delete Node : 9