Sort a stack using temporary two stack

// C program 
// Sort a stack using temporary two stack
// Time complexity O(n)
#include <stdio.h>

#include <stdlib.h>

// Define stack node
struct StackNode
{
    int 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");
    }
}
//Create a new node of stack
struct StackNode *newNode(int element, struct StackNode *next)
{
    //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 = next;
    }
    return node;
}
// 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, int element)
{
    // Add stack element
    stack->top = newNode(element, stack->top);
    stack->size++;
}
// return top element of stack
int peek(struct MyStack *stack)
{
    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--;
    }
}
// Print element of stack
void printData(struct MyStack *stack)
{
    struct StackNode *temp = stack->top;
    // iterate stack elements
    while (temp != NULL)
    {
        // Display element value
        printf("  %d", temp->element);
        temp = temp->next;
    }
    printf("\n");
}
// Transfer all stack t1 data into a stack t2
void transferData(struct MyStack *t1, struct MyStack *t2)
{
    int data = 0;
    // Executing the loop until when t1 stack element are not empty
    while (isEmpty(t1) == 0)
    {
        // Get the top element of t1 stack
        data = peek(t1);
        // Remove top of current t1 stack
        pop(t1);
        // Add data to t2 stack
        push(t2, data);
    }
}
// This is reverse the stack elements by using of auxiliary stacks
void reverseStack(struct MyStack *stack)
{
    // Create two auxiliary stacks
    struct MyStack *auxiliary1 = newStack();
    struct MyStack *auxiliary2 = newStack();
    // Send the all elements from actual stack into auxiliary1
    transferData(stack, auxiliary1);
    // Send the all elements from auxiliary1 into auxiliary2
    transferData(auxiliary1, auxiliary2);
    // Send the all elements from auxiliary2 into actual stack
    transferData(auxiliary2, stack);
}
int main()
{
    // Create a stack
    struct MyStack *stack = newStack();
    // Add elements
    push(stack, 1);
    push(stack, 2);
    push(stack, 3);
    push(stack, 4);
    push(stack, 5);
    push(stack, 6);
    push(stack, 7);
    push(stack, 8);

    /*
    Constructed stack
    ==========
        8  <-- Top
        7  
        6  
        5  
        4  
        3  
        2  
        1
    */
    // Display stack elements
    printf(" Before Reverse \n");
    printData(stack);
    // Perform reverse operation
    reverseStack(stack);

    /*
    After reverse
    ==========
        1  <-- Top
        2  
        3  
        4  
        5  
        6  
        7  
        8
    */
    // Display stack elements
    printf("\n After Reverse \n");
    printData(stack);
    return 0;
}

Output

 Before Reverse
  8  7  6  5  4  3  2  1

 After Reverse
  1  2  3  4  5  6  7  8