intoPostFix.cpp

#include <iostream>
#include <string>
using namespace std;

#define maxExpressionSize 100

int push(char stack[], int TOS, char ch) {
    if (TOS + 1 >= maxExpressionSize) {
        cout << "Overflow" << endl;
        return TOS;
    }
    TOS++;
    stack[TOS] = ch;
    return TOS;
}

int pop(char stack[], int TOS) {
    if (TOS < 0) {
        cout << "Underflow" << endl;
        return TOS;
    }
    TOS--;
    return TOS;
}

char peep(char stack[], int TOS) {
    return stack[TOS];
}

int precedence(char ch) {
    if (ch == '+' || ch == '-') return 1;
    if (ch == '*' || ch == '/') return 2;
    return -1; // For '(' or invalid characters
}

int isOperand(char ch) {
    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9');
}

int main() {
    string infixExpressionInput;
    cout << "Enter the infix expression: ";
    cin >> infixExpressionInput;
    
    int maxSize = infixExpressionInput.length();

    char outputExpression[maxSize + 1]; // Added 1 for null termination
    char stack[maxSize];
    int TOS = -1;
    int oTOS = -1;

    // Traverse the input expression
    for (int i = 0; i < maxSize; i++) {
        char ch = infixExpressionInput[i];

        // If the character is an operand, add it to output
        if (isOperand(ch)) {
            oTOS = push(outputExpression, oTOS, ch);
        }
        // If '(', push to stack
        else if (ch == '(') {
            TOS = push(stack, TOS, ch);
        }
        // If ')', pop until '(' is found
        else if (ch == ')') {
            while (TOS >= 0 && stack[TOS] != '(') {
                oTOS = push(outputExpression, oTOS, stack[TOS]);
                TOS = pop(stack, TOS);
            }
            TOS = pop(stack, TOS); // Pop the '('
        }
        // Operator encountered
        else {
            int currentPrecedence = precedence(ch);
            while (TOS >= 0 && precedence(stack[TOS]) >= currentPrecedence) {
                oTOS = push(outputExpression, oTOS, stack[TOS]);
                TOS = pop(stack, TOS);
            }
            TOS = push(stack, TOS, ch);
        }
    }

    // Pop remaining operators from the stack
    while (TOS >= 0) {
        oTOS = push(outputExpression, oTOS, stack[TOS]);
        TOS = pop(stack, TOS);
    }
    
    // Null terminate the output expression for printing
    outputExpression[oTOS + 1] = '\0';

    // Print the postfix expression
    cout << "Postfix expression: ";
    for (int i = 0; i <= oTOS; i++) {
        cout << outputExpression[i];
    }
    cout << endl;

    // Evaluate the postfix expression
    char postEvaluation[maxExpressionSize];
    int postTOS = -1;

    for (int i = 0; i <= oTOS; i++) {
        char c = outputExpression[i];
        if (isOperand(c)) {
            postTOS = push(postEvaluation, postTOS, c); // Push as char
        } else {
            int operand2 = peep(postEvaluation, postTOS) - '0'; // Convert char to int
            postTOS = pop(postEvaluation, postTOS);
            int operand1 = peep(postEvaluation, postTOS) - '0'; // Convert char to int
            postTOS = pop(postEvaluation, postTOS);
            int result;
            switch (c) {
            case '+':
                result = operand1 + operand2;
                break;
            case '-':
                result = operand1 - operand2;
                break;
            case '*':
                result = operand1 * operand2;
                break;
            case '/':
                result = operand1 / operand2;
                break;
            default:
                result = 0; // Handle default case
            }
            postTOS = push(postEvaluation, postTOS, result + '0'); // Convert back to char
        }
    }

    // The result will be on the top of the postEvaluation stack
    cout << "Result of postfix evaluation: " << (peep(postEvaluation, postTOS) - '0') << endl;

    return 0;
}