Infix to Prefix conversion using stack

Write a program to convert Infix to Prefix using stack

Example 1:

Input: infix="A+B*C+(E/F)*G^H"
Output: prefix= "+A+*BC*/EF^GH"

Approach :

Java

import java.util.HashMap;
import java.util.Stack;

public class InfixToPrefix {
    static HashMap<Character, Integer> precedence =
             new HashMap<Character, Integer>();

    public static void main(String[] args) {
        // infix
        String infix = "A+B*C+(E/F)*G^H";
        // precedence initialization
        operatorPrecedence();
        // infix to prefix
        String prefix = infixToPrefix(infix);
        System.out.println("Prefix is " + prefix);
    }

    private static String infixToPrefix(String infix) {
        String preFix = "";
        // stack for hold operator
        Stack<Character> stack = new Stack<>();
        // Iterate till given infix length
        infix = new StringBuffer(infix).reverse().toString();
        for (int i = 0; i < infix.length(); i++) {
            // hold char from infix
            char c = infix.charAt(i);
            // If letter then add into preFix
            if (Character.isLetter(c)) {
                preFix += infix.charAt(i);
            } else if (c == ')') {
                stack.add(c);
            } else if (c == '^') {
                stack.add(c);
            } else if (c == '(') { // if closing ) then
                // iterate till ( and add into preFix
                while (!stack.isEmpty() && stack.peek() != ')') {
                    preFix += stack.pop();
                }
                // if last char is ')' into stack then pop
                if (!stack.isEmpty() && stack.peek() == ')')
                    stack.pop();
            } else {
                // if precedence of c is greater then
                // top stack then add
                if (stack.isEmpty() || precedence.get(c) 
                    > precedence.getOrDefault(stack.peek(), 0)) {
                    stack.add(c);
                } else {
                    // iterate till precedence is less then equal and add
                    while (!stack.isEmpty() && precedence.get(c)
                         <= precedence.get(stack.peek())) {
                        preFix += stack.pop();
                    }
                    // add coming char
                    stack.add(c);
                }
            }

        }
        // iterate till stack is empty
        while (!stack.isEmpty()) {
            preFix += stack.pop();
        }
        preFix = new StringBuffer(preFix).reverse().toString();
        return preFix;
    }

    private static HashMap<Character, Integer> operatorPrecedence() {
        precedence.put('^', 10);
        precedence.put('*', 9);
        precedence.put('/', 9);
        precedence.put('-', 8);
        precedence.put('+', 8);
        return precedence;
    }
}   

C++

#include <bits/stdc++.h>
using namespace std;
map<char,int> precedence;
map<char,int> operatorPrecedence() 
{
        precedence['^']=10;
        precedence['*']=9;
        precedence['/']=9;
        precedence['-']=8;
        precedence['+']=8;
        return precedence;
}
string infixToPrefix(string infix)
{      
     string prefix = "";
    // stack for hold operator
    stack<char> stack;

    //revers the infix string
    reverse(infix.begin(),infix.end());
    // Iterate till given infix length
    for (int i = 0; i < infix.size(); i++)
     {
        // hold char from infix
        char c = infix[i];
        // If letter then add into prefix
         if (isalpha(c)) {
                prefix += c;
            } 
        else if (c == ')') 
        {
                stack.push(c);
        } 
        else if (c == '^')
          {
                stack.push(c);
         } 
        else if (c == '(')
              { // if closing ( then
                // iterate till ) and add into prefix
                while (!stack.empty() && stack.top() != ')') {
                    {
                        prefix += stack.top();
                        stack.pop();
                    }
                }
                // if last char is ')' into stack then pop
                if (!stack.empty() && stack.top() == ')')
                    stack.pop();
            } else {
                // if precedence of c is greater then 
                //top stack then add
                if (stack.empty() || precedence[c] >
                     precedence[stack.top()]) {
                    stack.push(c);
                } else {
                    // iterate till precedence is less then equal and add
                    while (!stack.empty() && precedence[c] 
                            <= precedence[stack.top()]) {
                        {
                            prefix += stack.top();
                            stack.pop();
                        }
                    }
                    // add coming char
                    stack.push(c);
                }
            }

        }
        // iterate till stack is empty
        while (!stack.empty()) {
           {
                prefix += stack.top();
                stack.pop();
           }
        }
      reverse(prefix.begin(),prefix.end());
        return prefix;
    }
int main()
{
   // infix
   string infix = "A+B*C+(E/F)*G^H";
   // precedence initialization
   operatorPrecedence();
   // infix to prefix
   string prefix = infixToPrefix(infix);
   cout<<"Prefix is ";
   cout<<prefix<<"\n";
   return 0;
}