Print all prime levels of a binary tree

// C program
// Print all prime 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;
    }
}
//Check that whether given number is prime or not
int is_prime(int num)
{
    if (num == 2 || num == 3 || num == 5)
    {
        return 1;
    }
    if (num <= 1 || (num % 2 == 0) || (num % 3 == 0) || (num % 5 == 0))
    {
        return 0;
    }

    int i = 11;
    
    while ((i *i) <= num)
    {
        if (num % i == 0)
        {
            //When number is divisible of current i value
            return 0;
        }
        else if (num % (i + 2) == 0)
        {
            //When number is divisible of current i + 2 value
            return 0;
        }
        i = i + 6;
    }
    return 1;
}
//Detect and print prime level nodes
void prime_level(struct Node *root)
{
    if (root != NULL)
    {
        //make a queue pointers
        struct MyQueue *front = NULL, *tail = NULL;
        struct MyQueue *temp = 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;
        struct Node *node = root;
        // Start to first node
        temp = front;
        //result node indicator
        int status = 0;
        int level = 0;
        // Get nodes of all levels in a queue
        while (temp != NULL)
        {
            //Tree node
            node = temp->element;
            level = temp->level;
            if (node->left != NULL)
            {
                //Add new left child node
                tail->next = enqueue(node->left);
                tail->next->level = level + 1;
                tail = tail->next;
            }
            if (node->right != NULL)
            {
                //Add new right child node
                tail->next = enqueue(node->right);
                tail->next->level = level + 1;
                tail = tail->next;
            }
            //Visit to next node queue
            temp = temp->next;
        }
        while (front != NULL)
        {
            temp = front;

            //Reset the indicator value
            status = 1;
            level = front->level;

            //Check that level node is prime or not
            while (status == 1 && temp != NULL && temp->level == front->level)
            {
                status = is_prime(temp->element->data);
                temp = temp->next;
            }
            temp = NULL;

            if (status == 1)
            {
                printf(" [");
            }
            // When level nodes are prime, 
            // Then this loop are printed node value and remove level nodes
            // Otherwise it's removing current level nodes
            while (front != NULL && front->level == level)
            {
                if (status == 1)
                {
                    //When all node is prime in a level
                    printf(" %d", front->element->data);
                }
                //remove  a queue node
                dequeue( &front);
            }
            if (status == 1)
            {
                printf(" ]\n");
            }
        }
        tail = NULL;
    }
    else
    {
        printf("Empty Tree\n");
    }
}
int main()
{
    struct Node *root = NULL;
    /*
    Construct Binary Tree
    -----------------------
               10
             /   \
            2     3
           /     / \
          4     9   5
         /  \    \    \
        7    53   37   31
            /  \
           19   23 
    -----------------------
    */
    //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(53);
    root->right->left->right = insert(37);
    root->right->right->right = insert(31);
    root->left->left->right->left = insert(19);
    root->left->left->right->right = insert(23);
    prime_level(root);
    return 0;
}

Output

 [ 2 3 ]
 [ 7 53 37 31 ]
 [ 19 23 ]