Construct Tree from given Inorder and Postorder

/*
    C Program 
    Construct binary tree from inorder and postorder 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 and postorder
struct Node *construct_tree(int inorder[], int postorder[], int first, int last, int *location)
{
	if ( *location < 0 || first > last)
	{
		return NULL;
	}
	struct Node *node = NULL;
	for (int i = first; i <= last && node == NULL; ++i)
	{
		//Find node
		if (postorder[ *location] == inorder[i])
		{
			// Create node
			node = get_node(inorder[i]);
			// next element of postorder
			*location = *location - 1;
			//Recursively constructing left and right subtree
			node->right = construct_tree(inorder, postorder, i + 1, last, location);
			node->left = construct_tree(inorder, postorder, first, i - 1, location);
		}
	}
	return node;
}
//handles the request of construct binary tree
struct Node *make_tree(int inorder[], int postorder[], int n1, int n2)
{
	if (n1 != n2)
	{
		//Invalid sequence
		return NULL;
	}
	else
	{
		int location = n2 - 1;
		return construct_tree(inorder, postorder, 0, n1 - 1, & location);
	}
}
//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()
{
	/*
	--------------
	        1
	      /   \
	     2     3 
	    / \   / \
	   4   5 9   7
	----------------  
	  
	*/
	int inorder[] = {
		4 , 2 , 5 , 1 , 9 , 3 , 7
	};
	int postorder[] = {
		4 , 5 , 2 , 9 , 7 , 3 , 1
	};
	// Get the size of arrays
	int n1 = sizeof(inorder) / sizeof(inorder[0]);
	int n2 = sizeof(postorder) / sizeof(postorder[0]);
	struct Node *root = make_tree(inorder, postorder, n1, n2);
	print_tree(root);
	return 0;
}

Output

 Preorder :   1  2  4  5  3  9  7
 Inorder :   4  2  5  1  9  3  7
 Postorder :   4  5  2  9  7  3  1