Construct Special Binary Tree from given Inorder Traversal

/*
    C Program 
    Construct Special Binary Tree from given Inorder Traversal
*/
#include <stdio.h>

#include <stdlib.h>

//Binary Tree node
struct Node
{
    int data;
    struct Node *left, *right;
};
//This is creating a binary tree node and return new node
struct Node *get_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;
}
//Display inorder elements
void print_inorder(struct Node *node)
{
    if (node != NULL)
    {
        print_inorder(node->left);
        //Print node value
        printf("  %d", node->data);
        print_inorder(node->right);
    }
}

//Display pre order elements
void print_preorder(struct Node *node)
{
    if (node != NULL)
    {
        //Print node value
        printf("  %d", node->data);
        print_preorder(node->left);
        print_preorder(node->right);
    }
}

//Display postorder elements
void print_postorder(struct Node *node)
{
    if (node != NULL)
    {
        print_postorder(node->left);

        print_postorder(node->right);

        //Print node value
        printf("  %d", node->data);
    }
}


//Constructing a binary tree from given inorder
struct Node * construct_tree(int inorder[], int first,int last)
{

    if(first > last)
    {
        return NULL;
    }
    int location = first;

    //Find largest element
    for (int i = first+1; i <= last; ++i)
    {
        if(inorder[i]>inorder[location])
        {
            location = i;
        }
    }

    struct Node*node = get_node(inorder[location]);

    node->left  = construct_tree(inorder,first,location-1);
    node->right = construct_tree(inorder,location+1,last);  

    return node;
}
//handles the request of construct binary tree
struct Node * make_tree(int inorder[], int n)
{
    if(n <= 0)
    {
        //Invalid sequence
        return NULL;
    }
    else
    {
        return construct_tree(inorder,0,n-1);
    }
}
//Handles the request of display the element of tree 
void print_tree(struct Node *root)
{
    printf("\n Preorder : ");    
    print_preorder(root);

    printf("\n Inorder : ");    
    print_inorder(root);

    printf("\n Postorder : ");    
    print_postorder(root);

    printf("\n");
}

int main()
{
    
    int inorder[]   = {7,2,6,1,8,4,12,9,0,11,3};  
    
    // Get the size
    int n = sizeof(inorder)/sizeof(inorder[0]);

    struct Node *root = make_tree(inorder,n);

    /*
            12
          /   \
         /     \
        /       \
       8        11
      /  \     /  \
     7    4   9    3
      \        \    
       6        0  
      / \
     2   1 
    ----------------  
    Resultant binary tree
    */
    print_tree(root);
    return 0;
}

Output

 Preorder :   12  8  7  6  2  1  4  11  9  0  3
 Inorder :   7  2  6  1  8  4  12  9  0  11  3
 Postorder :   2  1  6  7  4  8  0  9  3  11  12