Convert Ternary Expression to a Binary Tree Using Stack

/*
    C Program 
    Convert Ternary Expression to a Binary Tree
    Using Stack
*/
#include <stdio.h>

#include <stdlib.h>

//Binary Tree node
struct Node
{
	char data;
	struct Node *left, *right;
};
struct MyStack
{
	struct Node *element;
	struct MyStack *next;
};
//Create a MyStack element and return this reference
struct MyStack *push(struct Node *tree_node, struct MyStack **top)
{
	struct MyStack *node = (struct MyStack *) malloc(sizeof(struct MyStack));
	if (node != NULL)
	{
		//set pointer values
		node->element = tree_node;
		node->next = *top;*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(char 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("  %c", node->data);
		print_inorder(node->right);
	}
}
//Display pre order elements
void print_preorder(struct Node *node)
{
	if (node != NULL)
	{
		//Print node value
		printf("  %c", 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("  %c", node->data);
	}
}
// Check whether next node is valid in expression
int is_valid(char exp[], int i, int n)
{
	if (i + 1 < n && exp[i + 1] != '?' && exp[i + 1] != ':')
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
// Construct a binary tree using of ternary expression
struct Node *construct_tree(char exp[], int n)
{
	// Define loop controlling variable
	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 *result = NULL;
	// used to detect valid expression
	int status = 1;
	//Display given expression
	printf("\n Expression : %s\n", exp);
	//Construct tree
	while (i < n && status == 1)
	{
		if (exp[i] == '?')
		{
			if (top != NULL && is_valid(exp, i, n))
			{
				//Add next element in left side
				auxiliary = top->element;
				temp = get_node(exp[i + 1]);
				auxiliary->left = temp;
				push(temp, & top);
				i += 2;
			}
			else
			{
				status = 0;
			}
		}
		else if (exp[i] == ':')
		{
			if (top != NULL && is_valid(exp, i, n))
			{
				// next element in right child
				pop( & top);
				status = 0;
				auxiliary = NULL;
				// Find correct valid node to add new node in right side
				while (top != NULL && status == 0)
				{
					// Get the top element of stack
					auxiliary = top->element;
					if (auxiliary->right == NULL)
					{
						//When parent node exists
						status = 1;
					}
					else
					{
						pop( & top);
					}
				}
				if (status == 1)
				{
					// Create new node
					temp = get_node(exp[i + 1]);
					// Add node in right side
					auxiliary->right = temp;
					push(temp, & top);
					i += 2;
				}
			}
			else
			{
				status = 0;
			}
		}
		else
		{
			//Add new node
			temp = get_node(exp[i]);
			if (result == NULL)
			{
				result = temp;
			}
			push(temp, & top);
			i++;
		}
	}
	if (status == 1)
	{
		return result;
	}
	else
	{
		printf("\n Invalid Expression \n");
		return NULL;
	}
}
//handles the request of construct binary tree
struct Node *make_tree(char exp[], int n)
{
	if (n <= 0)
	{
		//Invalid sequence
		return NULL;
	}
	else
	{
		return construct_tree(exp, 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 exp[] = "a?b?c:d?e:f:g?h:i";
	// Get the size
	int size = sizeof(exp) / sizeof(exp[0]) - 1;
	struct Node *root = make_tree(exp, size);
	/*
	Resultant binary tree
	----------------------
	     a
	    / \ 
	   /   \
	  b     g
	 / \   / \
	c   d h   i
	   / \  
	  e   f
	----------------------
	Preorder :   a  b  c  d  e  f  g  h  i
	Inorder :   c  b  e  d  f  a  h  g  i
	Postorder :   c  e  f  d  b  h  i  g  a
	*/
	print_tree(root);
	return 0;
}

Output

 Expression : a?b?c:d?e:f:g?h:i

 Preorder :   a  b  c  d  e  f  g  h  i
 Inorder :   c  b  e  d  f  a  h  g  i
 Postorder :   c  e  f  d  b  h  i  g  a