Construct Tree from given Inorder and Preorder Traversals

/*
    C Program 
    Construct Tree from given Inorder and Preorder traversals
*/
#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 preorder
struct Node *construct_tree(int inorder[], int preorder[], int first, int last, int *location, int size)
{
	if ( *location > size || first > last)
	{
		return NULL;
	}
	struct Node *node = NULL;
	for (int i = first; i <= last && node == NULL; ++i)
	{
		//Find node
		if (preorder[ *location] == inorder[i])
		{
			// Create node
			node = get_node(inorder[i]);
			// next element of preorder
			*location = *location + 1;
			//Recursively constructing left and right subtree
			node->left = construct_tree(inorder, preorder, first, i - 1, location, size);
			node->right = construct_tree(inorder, preorder, i + 1, last, location, size);
		}
	}
	return node;
}
//handles the request of construct binary tree
struct Node *make_tree(int inorder[], int preorder[], int n1, int n2)
{
	if (n1 != n2)
	{
		//Invalid sequence
		return NULL;
	}
	else
	{
		int location = 0;
		return construct_tree(inorder, preorder, 0, n1 - 1, & location, n2 - 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()
{
	/*
	----------------------------
	         8
	       /   \
	      2     7
	     / \   / \
	    6   9 4   5
	   / \       / \
	  1   3     23  90
	-------------------------------
	Inorder  sequence: 1  6  3  2  9   8   4   7   23  5    90
	Preorder sequence: 8  2  6  1  3   9   7   4   5   23   90
	*/
	int inorder1[] = {
		1 , 6 , 3 , 2 , 9 , 8 , 4 , 7 , 23 , 5 , 90
	};
	int preorder1[] = {
		8 , 2 , 6 , 1 , 3 , 9 , 7 , 4 , 5 , 23 , 90
	};
	// Get the size of arrays
	int n1 = sizeof(inorder1) / sizeof(inorder1[0]);
	int n2 = sizeof(preorder1) / sizeof(preorder1[0]);
	struct Node *root1 = make_tree(inorder1, preorder1, n1, n2);
	print_tree(root1);
	/*
	--------------
	        1
	      /   \
	     2     3 
	    / \   / \
	   4   5 9   7
	----------------  
	  
	*/
	int inorder2[] = {
		4 , 2 , 5 , 1 , 9 , 3 , 7
	};
	int preorder2[] = {
		1 , 2 , 4 , 5 , 3 , 9 , 7
	};
	// Get the size of arrays
	n1 = sizeof(inorder2) / sizeof(inorder2[0]);
	n2 = sizeof(preorder2) / sizeof(preorder2[0]);
	struct Node *root2 = make_tree(inorder2, preorder2, n1, n2);
	print_tree(root2);
	return 0;
}

Output

 Preorder :   8  2  6  1  3  9  7  4  5  23  90
 Inorder :   1  6  3  2  9  8  4  7  23  5  90
 Postorder :   1  3  6  9  2  4  23  90  5  7  8

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