equation conversion

#include <iostream>
#include <string>
#include <stack>
#include <algorithm>

using namespace std;

int priority(char alpha) {
    if (alpha == '+' || alpha == '-')
        return 1;
    if (alpha == '*' || alpha == '/')
        return 2;
    if (alpha == '^')
        return 3;
    return 0;
}

string infixtopostfix(string infix) {
    string postfix = "";
    stack<char> stack;

    for (char& c : infix) {
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
            postfix += c;
        } else if (c == '(') {
            stack.push(c);
        } else if (c == ')') {
            while (!stack.empty() && stack.top() != '(') {
                postfix += stack.top();
                stack.pop();
            }
            stack.pop();
        } else {
            while (!stack.empty() && priority(c) <= priority(stack.top())) {
                postfix += stack.top();
                stack.pop();
            }
            stack.push(c);
        }
    }

    while (!stack.empty()) {
        postfix += stack.top();
        stack.pop();
    }

    return postfix;
}

void reverseString(string& str) {
    reverse(str.begin(), str.end());
}

void infixToPrefix(string& infix, string& prefix) {
    reverseString(infix);

    for (char& c : infix) {
        if (c == '(') {
            c = ')';
        } else if (c == ')') {
            c = '(';
        }
    }

    reverseString(infix);

    prefix = infix;
}

bool isOperator(char x) {
    return (x == '+' || x == '-' || x == '*' || x == '/' || x == '^');
}

string prefixToInfix(string prefix, int& index) {
    string infix = "";
    
    if (isOperator(prefix[index])) {
        infix += "(";
        infix += prefixToInfix(prefix, ++index);
        infix += prefix[index++];
        infix += prefixToInfix(prefix, ++index);
        infix += ")";
    } else {
        infix += prefix[index++];
    }
    
    return infix;
}

string convertPrefixToInfix(string prefix) {
    int index = 0;
    return prefixToInfix(prefix, index);
}

string getInfix(string exp) {
    stack<string> s;
 
    for (char c : exp) {
        if (isOperator(c)) {
            string op1 = s.top();
            s.pop();
            string op2 = s.top();
            s.pop();
            s.push("(" + op2 + c + op1 + ")");
        } else {
            s.push(string(1, c));
        }
    }
    return s.top();
}

string postToPre(string post_exp) {
    stack<string> s;
    
    for (char c : post_exp) {
        if (isOperator(c)) {
            string op1 = s.top();
            s.pop();
            string op2 = s.top();
            s.pop();
            string temp = c + op2 + op1;
            s.push(temp);
        } else {
            s.push(string(1, c));
        }
    }

    string ans = "";
    while (!s.empty()) {
        ans += s.top();
        s.pop();
    }
    return ans;
}

string preToPost(string pre_exp) {
    stack<string> s;
    
    for (int i = pre_exp.size() - 1; i >= 0; i--) {
        if (isOperator(pre_exp[i])) {
            string op1 = s.top();
            s.pop();
            string op2 = s.top();
            s.pop();
            string temp = op1 + op2 + pre_exp[i];
            s.push(temp);
        } else {
            s.push(string(1, pre_exp[i]));
        }
    }
    return s.top();
}

int main() {
    string expression, result;
    int choice;

    cout << "Select one of the following:" << endl;
    cout << "1) Infix to postfix" << endl;
    cout << "2) Infix to prefix" << endl;
    cout << "3) Prefix to infix" << endl;
    cout << "4) Postfix to infix" << endl;
    cout << "5) Postfix to prefix" << endl;
    cout << "6) Prefix to postfix" << endl;
    cin >> choice;

    cout << "Enter an expression: ";
    cin >> expression;

    switch (choice) {
        case 1:
            result = infixtopostfix(expression);
            cout << "Postfix expression: " << result << endl;
            break;
        case 2:
            infixToPrefix(expression, result);
            cout << "Prefix expression: " << result << endl;
            break;
        case 3:
            result = convertPrefixToInfix(expression);
            cout << "Infix expression: " << result << endl;
            break;
        case 4:
            result = getInfix(expression);
            cout << "Infix expression: " << result << endl;
            break;
        case 5:
            result = postToPre(expression);
            cout << "Prefix expression: " << result << endl;
            break;
        case 6:
            result = preToPost(expression);
            cout << "Postfix expression: " << result << endl;
            break;
        default:
            cout << "Invalid choice!" << endl;
    }

    return 0;
}