Construct BST from given preorder traversal using stack

/*
    C Program 
    Construct BST from given preorder traversal using stack
*/
#include <stdio.h>
#include <stdlib.h>

// Tree Node
struct TreeNode
{
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
};

// Binary Search Tree
struct BinarySearchTree
{
    struct TreeNode *root;
};

// Define stack node
struct StackNode
{
    struct TreeNode * element;
    struct StackNode *next;
};
// Define a custom stack
struct MyStack
{
    struct StackNode *top;
    int size;
};

struct MyStack *newStack()
{
    //Make a stack
    struct MyStack *stack = (struct MyStack *) malloc(sizeof(struct MyStack));
    if (stack != NULL)
    {
        //Set node values
        stack->top = NULL;
        stack->size = 0;
    }
    else
    {
        printf("\nMemory overflow when create new stack\n");
    }
}
// Returns the status of empty or non empty stacks
int isEmpty(struct MyStack *stack)
{
    if (stack->size > 0 && stack->top != NULL)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
// Add node at the top of stack
void push(struct MyStack *stack, struct TreeNode* element)
{

    // Make a new node
    struct StackNode *node = (struct StackNode *) malloc(sizeof(struct StackNode));
    if (node == NULL)
    {
        printf("\nMemory overflow when create new stack Node \n");
    }
    else
    {
        node->element = element;
        node->next    = stack->top;
    }

    // Add stack element
    stack->top = node;
    stack->size++;
}
// return top element of stack
struct TreeNode * peek(struct MyStack *stack)
{
    if(stack->top == NULL)
    {
        return NULL;
    }
    return stack->top->element;
}
// Remove top element of stack
void pop(struct MyStack *stack)
{
    if (isEmpty(stack) == 0)
    {
        struct StackNode *temp = stack->top;
        // Change top element of stack
        stack->top = temp->next;
        // remove previous top
        free(temp);
        temp = NULL;
        stack->size--;
    }
}

// Create new tree
struct BinarySearchTree *newTree()
{
    // Create dynamic node
    struct BinarySearchTree *tree = (struct BinarySearchTree *) malloc(sizeof(struct BinarySearchTree));

    if (tree != NULL)
    {
        tree->root = NULL;
    }
    else
    {
        printf("Memory Overflow to Create tree Tree\n");
    }
    // return new tree
    return tree;
}
// returns a new node of tree
struct TreeNode *newTreeNode(int data)
{
    // Create dynamic node
    struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    if (node != NULL)
    {
        //Set data and pointer values
        node->data = data;
        node->left = NULL;
        node->right = NULL;
    }
    else
    {
        //This is indicates, segmentation fault or memory overflow problem
        printf("Memory Overflow\n");
    }
    //return new node
    return node;
}
// Handle request to construct bst using given preorder sequence
struct BinarySearchTree *makeTree(int preorder[],int n)
{
    if(n <= 0)
    {
        return NULL;
    }
    // Create an empty tree
    struct BinarySearchTree *tree = newTree();

    // Create an empty stack
    struct MyStack* st = newStack();

    // Create first node of tree
    struct TreeNode* node = newTreeNode(preorder[0]);

    // Add first element into stack
    push(st,node);

    tree->root = node;

    int i = 1;

    while(i < n)
    {
        
        node = NULL;
        // Find new inserted node position
        while(isEmpty(st)==0 && peek(st)->data < preorder[i] )
        {
            // Get the  top element of stack
            node =  peek(st);
            // Remove top element of stack
            pop(st);
        }

        if(node!=NULL)
        {
            // Add node in right subtree
            node->right = newTreeNode(preorder[i]);
            //  Add stack element
            push(st,node->right);
        }
        else
        {
            // Get the  top element of stack
            node = peek(st); 

            // Add node in left subtree
            node->left = newTreeNode(preorder[i]);
            //  Add stack element
            push(st,node->left);
        }

        i++;
    }

    return tree;
}


//Display inorder elements
void printInorder(struct TreeNode *node)
{
    if (node != NULL)
    {
        printInorder(node->left);
        //Print node value
        printf("  %d", node->data);
        printInorder(node->right);
    }
}
//Display pre order elements
void printPreorder(struct TreeNode *node)
{
    if (node != NULL)
    {
        //Print node value
        printf("  %d", node->data);
        printPreorder(node->left);
        printPreorder(node->right);
    }
}
//Display postorder elements
void printPostorder(struct TreeNode *node)
{
    if (node != NULL)
    {
        printPostorder(node->left);
        printPostorder(node->right);
        //Print node value
        printf("  %d", node->data);
    }
}
//Handles the request of display the element of tree 
void printTree(struct TreeNode *root)
{
    if (root == NULL)
    {
        return;
    }
    // Display tree elements in three formats
    printf("\n Preorder : ");
    printPreorder(root);
    printf("\n Inorder : ");
    printInorder(root);
    printf("\n Postorder : ");
    printPostorder(root);
    printf("\n");
}
int main()
{   
    int preorder[] = {15,13,12,11,14,20,19,17,18,21,22};

    int n = sizeof(preorder)/sizeof(preorder[0]);

    struct BinarySearchTree *tree = makeTree(preorder, n);
    /*
                15
             /     \
            13      20
           /  \     / \
          12  14   19  21
         /        /      \
        11       17       22
                  \
                   18
        -----------------------
        Built binary search tree         
    */  
    printTree(tree->root);
   
    
    return 0;
}

Output

 Preorder :   15  13  12  11  14  20  19  17  18  21  22
 Inorder :   11  12  13  14  15  17  18  19  20  21  22
 Postorder :   11  12  14  13  18  17  19  22  21  20  15