Construct tree from given string parenthesis expression

/*
    C Program 
    Construct tree from given string parenthesis expression 
*/
#include <stdio.h>
#include <stdlib.h>

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

struct MyStack
{
	struct Node *element;
	int indicator;
	struct MyStack *next;
};
//Create a MyStack element and return this reference
struct MyStack *push(struct Node *tree_node, struct MyStack **top, int indicator)
{
	struct MyStack *node = (struct MyStack *) malloc(sizeof(struct MyStack));
	if (node != NULL)
	{
		//set pointer values
		node->element = tree_node;
		node->next = *top;
		node->indicator = indicator;*top = node;
	}
	else
	{
		printf("Memory Overflow\n");
	}
	return node;
}
//Remove a top node of stack
void pop(struct MyStack **top)
{
	if ( *top != NULL)
	{
		struct MyStack *remove = *top;
        *top = remove->next;
		remove->element = NULL;
		remove->next = NULL;
		//free the allocated memory of node
		free(remove);
		remove = NULL;
	}
}
//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 string 
// 1) expression can be contains positive number example (1,44,2324,55 etc)
// 2) Expression contains parentheses which is indicates is left and right child
//  Example 1 : () null child, other (4) child with node 4 
struct Node *construct_tree(char str[], int n)
{
	// Define loop controlling variables
	int j = 0;
	int i = 0;
	// Define stack variable
	struct MyStack *top = NULL;
	// Define some useful Tree node variables
	struct Node *auxiliary = NULL;
	struct Node *temp = NULL;
	struct Node *child = NULL, *parent = NULL;
	// Define some auxiliary variables
	int num = 0;
	int position = 0;
	//Display given expression
	printf("\n Expression : %s\n", str);
	//Construct tree
	while (i < n)
	{
		if (str[i] == '(')
		{
			// Add null node
			temp = NULL;
			push(temp, &top, 0);
			i++;
		}
		else if (str[i] == ')')
		{
			position = 0;
			// Reset the value of parent and child node
			child = NULL;
			parent = NULL;
			if (top != NULL)
			{
				//Get child node
				child = top->element;
				pop( &top);
			}
			if (top != NULL)
			{
				//Get parent node
				parent = top->element;
				position = top->indicator;
				pop(&top);
			}
			if (parent != NULL)
			{
				//connect parent to child node
				if (position == 0)
				{
					// Add node in left side
					parent->left = child;
					position = 1;
				}
				else if (position == 1)
				{
					// Add node in right side
					parent->right = child;
					position = 2;
				}
				else
				{
					// Tree exist More than 2 child nodes
					// example  x(1)(2)(3) x is parent
					printf("\n More than 2 child of node %d\n", parent->data);
					return NULL;
				}
				push(parent, &top, position);
			}
			i++;
		}
		else if (str[i] >= '1' && str[i] <= '9')
		{
			num = 0;
			// Collect node value
			while (i < n && str[i] != '(' && str[i] != ')')
			{
				num = (num *10) + (str[i] - '0');
				i++;
			}
			// Get new tree node
			temp = get_node(num);
			if (top != NULL)
			{
				auxiliary = top->element;
				if (auxiliary == NULL)
				{
					// When stack top node element is empty then add new node to this location
					top->element = temp;
				}
				else
				{
					// Add new node in tree
					push(temp, &top, 0);
				}
			}
			else
			{
				// When stack is empty, then add first node
				push(temp, &top, 0);
			}
		}
		else
		{
			// When not a valid expression
			printf("\n Invalid Expression \n");
			return NULL;
		}
	}
	if (top != NULL)
	{
		auxiliary = top->element;
		pop(&top);
		return auxiliary;
	}
	else
	{
		return NULL;
	}
}
//handles the request of construct binary tree
struct Node *make_tree(char str[], int n)
{
	if (n <= 0)
	{
		//Invalid sequence
		return NULL;
	}
	else
	{
		return construct_tree(str, n);
	}
}
//Handles the request of display the element of tree 
void print_tree(struct Node *root)
{
	if (root == NULL)
	{
		return;
	}
	// Display tree elements in three formats
	printf("\n Preorder : ");
	print_preorder(root);
	printf("\n Inorder : ");
	print_inorder(root);
	printf("\n Postorder : ");
	print_postorder(root);
	printf("\n");
}
int main()
{
	// string expression
	char str[] = "16(7(4()(6))(2))(8(9()(1))(3(15)))";
	// Get the size
	int size = sizeof(str) / sizeof(str[0]) - 1;
	struct Node *root = make_tree(str, size);
	/*
	        16
	      /    \
	     /      \
	    /        \
	   7         8
	  /  \     /   \
	 4    2   9     3
	  \        \   /  
	   6        1 15  
	----------------  
	Resultant binary tree
	*/
	print_tree(root);
	return 0;
}

Output

 Expression : 16(7(4()(6))(2))(8(9()(1))(3(15)))

 Preorder :   16  7  4  6  2  8  9  1  3  15
 Inorder :   4  6  7  2  16  9  1  8  15  3
 Postorder :   6  4  2  7  1  9  15  3  8  16