Check if all levels of two trees are anagrams or not

/*
    C Program 
    Check if all levels of two trees are anagrams or not
*/
#include <stdio.h>
#include <stdlib.h>


//Queue node
struct QueueNode
{
    int level;
    struct TreeNode *element;
    struct QueueNode *next;
};
// Define queue
struct MyQueue
{
   
    struct QueueNode*front;
    struct QueueNode*tail;

};

// Binary Tree node
struct TreeNode
{
    int data;
    struct TreeNode *left, *right;
};

struct BinaryTree
{
    struct TreeNode*root;
};

struct MyQueue* make_queue()
{

    // Create dynamic node of MyQueue
    struct MyQueue *node = (struct MyQueue *) malloc(sizeof(struct MyQueue));

    if(node==NULL)
    {
        printf("\nMemory Overflow, when creating a new Queue\n");
    }
    else
    {
        node->front = NULL;
        node->tail  = NULL;
    }
    return node;
}

struct BinaryTree* make_tree()
{

    // Create dynamic node of BinaryTree
    struct BinaryTree *node = (struct BinaryTree *) malloc(sizeof(struct BinaryTree));

    if(node==NULL)
    {
        printf("\nMemory Overflow, when creating a new BinaryTree\n");
    }
    else
    {
        node->root = NULL;
    }
    return node;
}
int is_empty(struct MyQueue*queue)
{
    if(queue == NULL || queue->front==NULL)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

//Create a queue node and returns this node
void enqueue(struct MyQueue*queue , struct TreeNode *tree_node)
{
    //Make a new Queue node
    struct QueueNode *new_node = (struct QueueNode *) malloc(sizeof(struct QueueNode));

    if (new_node != NULL)
    {
        //Set node values
        new_node->element = tree_node;
        new_node->next    = NULL;

        if(queue->front==NULL)
        {
            queue->front = new_node;
        
            queue->tail  = queue->front;
        }
        else
        {
            queue->tail->next = new_node;

            queue->tail = new_node;
        }
    }
    else
    {
        printf("\nMemory Overflow, when creating a new Queue Node\n");
    }
 
}

//Remove a queue elements
void dequeue(struct MyQueue*queue)
{
    if ( is_empty(queue)==0)
    {
        struct QueueNode *remove = queue->front;

        if(queue->front==queue->tail)
        {
            queue->tail = NULL;
        }
        
        queue->front= queue->front->next;
        
        remove->element = NULL;
        remove->next = NULL;
        //free node
        free(remove);
        remove = NULL;
    }
}

// Return front element of queue
struct TreeNode* peek(struct MyQueue*queue)
{
    if(is_empty(queue)==1)
    {
        return NULL;
    }
    else
    {
        return queue->front->element;
    }
}
void inorder(struct TreeNode*node)
{
    if(node!=NULL)
    {

        inorder(node->left);
        printf("  %d",node->data);
        inorder(node->right);
    }
}
// Determine two trees are anagram or not 
void is_anagrams(struct TreeNode*tree1,struct TreeNode*tree2)
{

    //result indicators
    int status = 1;

    // Create queue variables
    struct MyQueue *queue1 = make_queue();

    struct MyQueue *queue2 = make_queue();


    // Add first node of queue
    enqueue(queue1,tree1);
    enqueue(queue2,tree2);


    // Define tree nodes
    struct TreeNode *node1 = NULL;
    struct TreeNode *node2 = NULL;

    //print tree elements
    printf("\n First Tree \n");
    inorder(tree1);
    printf("\n Second Tree \n");
    inorder(tree2);
    // 
    while(is_empty(queue1)==0 || is_empty(queue2)==0)
    {

        if(status==1)
        {
            // Get the front element of both queue 
            node1 = peek(queue1);
            node2 = peek(queue2);

         
            if( 
                (  node1  == NULL && node2 != NULL) 
                || (node1 != NULL && node2 == NULL) 
                || (node1 != NULL && node2 != NULL  && node1->data != node2->data))
            {
                //When both queue front node are not same (That is based on values or null nodes )
                status = 0;
            }
            else
            {
                if(node1->left != NULL)
                {

                    enqueue(queue1,node1->left);
                }
                if(node1->right != NULL)
                {
                    enqueue(queue1,node1->right);
                }
                
                if(node2->right!=NULL)
                {
                    enqueue(queue2,node2->right);
                }
                if(node2->left!=NULL)
                {
                    enqueue(queue2,node2->left);
                }

                dequeue(queue1);
                dequeue(queue2);
                
            }
        }
        else
        {
            if(is_empty(queue1)==0)
            {
                dequeue(queue1);
            }
            if(is_empty(queue2)==0)
            {
                dequeue(queue2);
            }
            status = 0;
        }

    }
   
    
    if(status==0)
    {
        printf("\n Anagram not exist \n");
    }
    else
    {
        printf("\n Anagram exist \n");
    }


}

//This is creating a binary tree node and return new node
struct TreeNode *get_tree_node(int data)
{
    // Create dynamic node
    struct TreeNode *new_node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    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("\nMemory Overflow, when creating a new Tree Node\n");
    }
    //return new node
    return new_node;
}


int main()
{
    struct BinaryTree*tree1= make_tree();
    struct BinaryTree*tree2= make_tree();
    struct BinaryTree*tree3= make_tree();
    /*
             8
           /   \
          7     4
         /     /  \
        3     9    2
             / \
            5   6   
    ------------------ 
    Constructing binary tree    
    */
    tree1->root = get_tree_node(8);
    tree1->root->left = get_tree_node(7);
    tree1->root->left->left = get_tree_node(3);
    tree1->root->right = get_tree_node(4);
    tree1->root->right->left = get_tree_node(9);
    tree1->root->right->right = get_tree_node(2);
    tree1->root->right->left->left = get_tree_node(5);
    tree1->root->right->left->right = get_tree_node(6);
    /*
             8
           /   \
          4     7
         /  \    \
        2    9    3
            / \
           6   5 
     ----------------- 
    Second Constructing binary tree 
    */

    tree2->root = get_tree_node(8);
    tree2->root->right = get_tree_node(7);
    tree2->root->right->right = get_tree_node(3);
    tree2->root->left = get_tree_node(4);
    tree2->root->left->right = get_tree_node(9);
    tree2->root->left->left = get_tree_node(2);
    tree2->root->left->right->right = get_tree_node(5);
    tree2->root->left->right->left = get_tree_node(6);

    /*
             8
           /   \
          4     7
         /  \    \
        2    6    3
              \
               9 
                \
                 5  
     ----------------- 
    Third Constructing binary tree 
    */

    tree3->root = get_tree_node(8);
    tree3->root->right = get_tree_node(7);
    tree3->root->right->right = get_tree_node(3);
    tree3->root->left = get_tree_node(4);
    tree3->root->left->right = get_tree_node(6);
    tree3->root->left->left = get_tree_node(2);
    tree3->root->left->right->right = get_tree_node(9);
    tree3->root->left->right->right->right = get_tree_node(5);

    // Test case
    is_anagrams(tree1->root,tree2->root);
    is_anagrams(tree2->root,tree3->root);
   
    return 0;
}

Output

 First Tree
  3  7  8  5  9  6  4  2
 Second Tree
  2  4  6  9  5  8  7  3
 Anagram exist

 First Tree
  2  4  6  9  5  8  7  3
 Second Tree
  2  4  6  9  5  8  7  3
 Anagram not exist