Infix2Postfix

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE 80 //The limit of expression length

typedef struct _stackNode{
  char item;
  struct _stackNode *next;
}StackNode;

typedef struct _stack{
  int size;
  StackNode *head;
}Stack;

void push(Stack *sPtr, char item);
int pop(Stack *sPtr);
char peek(Stack s);
int isEmptyStack(Stack s);

void in2Post(char*, char*);

int main()
{
  char infix[SIZE] = {};
  char postfix[SIZE] = {};

  printf("Enter an infix expression:\n");
  gets(infix);

  in2Post(infix,postfix);
  printf("The postfix expression is \n");
  printf("%s\n",postfix);
  return 0;
}

void in2Post(char* infix, char* postfix)
{
  Stack opStack = {};
  char* postfixCurrent = postfix; // where we append to "postfix" (pointer of the first blank index)
  for (char* c = infix; *c != '\0'; c++)
  {
    printf("Current Char: %c\n", *c);

    if (*c == '(')  // Open brackets has the "highest precedence" and will always be pushed into opStack.
    {
      push(&opStack, *c);
    }
    // A closed brackets means we have finished with the 'entire expression' within the brackets so we just pop all the operatos into the postfix expression until we reach the opening bracket '(',
    // this is similar to when we finish scanning the whole infix expression, we just pop everything from opStack into the postfix expression (think of the entire infix expression being in 1 large bracket)
    else if (*c == ')')
    {
      while (peek(opStack) != '(')
      {
        *postfixCurrent = peek(opStack);
        pop(&opStack);
        postfixCurrent++;
      }
      pop(&opStack);
    }
    else if (strchr("+-*/", *c)) // For the case of operators
    {
      printf("OPERATOR!!\n");
      // Only push if this operator is higher precedence than the one in stack, or if we reach a '(' (the start of the current bracket we are in) or if the stack is empty
      // Else we keep popping the stack into the postfix expression until one of the above condition is met.
        while (!isEmptyStack(opStack) && peek(opStack) != '(' && (!((strchr("*/", *c)) && strchr("+-", peek(opStack)))))
        {
          printf("SAME OR LOWER PRECEDENCE, POP AND PUSH UNTIL SATISFIED!\n");
          *postfixCurrent = peek(opStack);
          postfixCurrent++; // Increment for 'postfix'
          pop(&opStack);
        }
        printf("NOW HIGHER PRECEDENCE / EMPTY / '(' , PUSH!\n");
        push(&opStack, *c);
    }
    else  // Operands, we just append to postfix expression
    {
      *postfixCurrent = *c;
      postfixCurrent++;
    }
  }

  // Pop all remaining operators into postfix expression
  while (!isEmptyStack(opStack))
  {
    *postfixCurrent = peek(opStack);
    pop(&opStack);
    postfixCurrent++;
  }
}

void push(Stack *sPtr, char item){
  StackNode *newNode;
  newNode = malloc(sizeof(StackNode));
  newNode->item = item;
  newNode->next = sPtr->head;
  sPtr->head = newNode;
  sPtr->size++;
}

int pop(Stack *sPtr){
  if(sPtr == NULL || sPtr->head == NULL){
  return 0;
  }
  else{
   StackNode *temp = sPtr->head;
   sPtr->head = sPtr->head->next;
   free(temp);
   sPtr->size--;
   return 1;
  }
}

char peek(Stack s){
  return s.head->item;
}

int isEmptyStack(Stack s){
   if(s.size == 0) return 1;
   else return 0;
}