Print binary tree level in sorted order

// C program
// Print binary tree level in sorted order

#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;
    }
}

//Add element in sorted order
void priority_queue(struct MyQueue **result,struct Node *tree_node)
{
    //Make a new Queue node
    struct MyQueue *new_node = (struct MyQueue * ) malloc(sizeof(struct MyQueue));


    if (new_node != NULL)
    {
        new_node->element = tree_node;
        new_node->next = NULL;

        if(*result==NULL)
        {
            //When first node of queue
            *result = new_node;
        }
        else if((*result)->element->data >= tree_node->data)
        {
            //Add node at begining
            new_node->next = *result;

            *result = new_node;
        }
        else
        {
            struct MyQueue*temp = *result;
            
            //Find insert node location
            while(temp->next!=NULL && temp->next->element->data < tree_node->data)
            {
                temp = temp->next;
            }

            new_node->next = temp->next;

            temp->next = new_node;
        }
    }
    else
    {
        printf("Memory Overflow\n");
       
    }

}
//Print sorted level of binary tree
void show_level(struct MyQueue**result)
{
    if(*result==NULL)
    {
        return;
    }
    struct MyQueue*temp=*result;
    printf("\n[");
    while(*result!=NULL)
    {
        temp = *result;

        *result = temp->next;

        printf(" %d",temp->element->data);
        temp->element = NULL;
        free(temp);
        temp = NULL;
    }
      printf(" ]");
}

//Get sorted level in binary tree
void sorted_level(struct Node *root)
{
    if (root != NULL)
    {
        //create queue variables
        struct MyQueue *front = NULL, *tail = NULL;


        //This are used to store sorted level of tree element
        //like priority queue
        struct MyQueue *result = NULL;

        //Get first node of tree
        front = enqueue(root);
        //Start level of first node is one
        front->level = 1;

        tail = front;


        int level_counter = 1;

        struct Node *node = root;

        printf("\nSorted Level ");
   
        //Execute loop until the queue is not empty
        while (front != NULL)
        {

            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 != level_counter)
            {
                
                //When level change
                level_counter = front->level;

                //Display sorted elemet
                show_level(&result);
            }

            //Add current node into priority queue
            priority_queue(&result,node);
            //remove element of queue
            dequeue( &front); 
        }

        tail = NULL;

        //Display sorted elemet in last level
        show_level(&result);
    }
    else
    {
        printf("Empty Linked List\n");
    }
}
int main()
{
    struct Node *root = NULL;
    /*  
    Construct Binary Tree
    -----------------------
                1
             /    \
            3       2
           /       / \
          4       9   6
         /  \    / \    \
        7    8  2   4    10
    */
    //Add node
    root = insert(1);
    root->left = insert(3);
    root->right = insert(2);
    root->right->right = insert(6);
    root->right->left = insert(9);
    root->right->left->left = insert(2);
    root->left->left = insert(4);
    root->left->left->left = insert(7);
    root->left->left->right = insert(8);
    root->right->left->right = insert(4);
    root->right->right->right = insert(10);
    
    //level element in sorted order 
    sorted_level(root);

    return 0;
}

Output

Sorted Level
[ 1 ]
[ 2 3 ]
[ 4 6 9 ]
[ 2 4 7 8 10 ]