1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93

/* Do the conversion */
  while (!isEmpty_2(stackPtr) && infix[i] != '\0') {
    c = infix[i++];

    if (my_isdigit(c) || my_isalpha(c)) {
      while (my_isdigit(c) || my_isalpha(c)) {
        postfix[j++] = c;
        c = infix[i++];
      }
      postfix[j++] = ' ';

      if (c == ')' || isOperator_2(c))
        i--;
    } else if (c == '(')
      push_2(&stackPtr, '(');
    else if (isOperator_2(c) == 1) {
      if (!isEmpty_2(stackPtr) && isOperator_2(stackTop_1(stackPtr))) {
        while (isOperator_2(stackTop_1(stackPtr)) &&
               (precedence_1(stackTop_1(stackPtr), c)) >= 0) {
          postfix[j++] = pop_2(&stackPtr);
          postfix[j++] = ' ';
        }
        push_2(&stackPtr, c);
      } else
        push_2(&stackPtr, c);
    } else if (c == ')') {
      if (!isEmpty_2(stackPtr)) {
        c = pop_2(&stackPtr);

        while (!isEmpty_2(stackPtr) && c != '(') {
          postfix[j++] = c;
          postfix[j++] = ' ';
          c = pop_2(&stackPtr);
        }
      }
    }
  }
  postfix[j] = '\0';
}

int precedence_1(char operator1, char operator2) {
  int result = 1;

  switch (operator1) {
  case '^':
    if (operator2 == '^')
      result = 0;
    break;
  case '*':
  case '/':
  case '%':
    switch (operator2) {
    case '^':
      result = -1;
      break;
    case '*':
    case '/':
    case '%':
      result = 0;
      break;
    default:
      break;
    }
    break;
  case '+':
  case '-':
    switch (operator2) {
    case '-':
    case '+':
      result = 0;
      break;
    default:
      result = -1;
      break;
    }
    break;
  }

  return result;
}

void push_2(StackNodePtr_2 *topPtr, int info) {
  StackNodePtr_2 newPtr;

  newPtr = malloc(sizeof(StackNode_2)); /* Now points to a place in memory*/

  if (newPtr != NULL) {
    newPtr->data = info;
    newPtr->nextPtr = *topPtr;
    *topPtr = newPtr;
  } else
    printf("%c not inserted. No memory available.\n", info);
}