# Prefix to Infix Conversion

Infix : An expression is called the Infix expression if the operator appears in between the operands in the expression. Simply of the form (operand1 operator operand2).
Example : (A+B) * (C-D)

Prefix : An expression is called the prefix expression if the operator appears in the expression before the operands. Simply of the form (operator operand1 operand2).
Example : *+AB-CD (Infix : (A+B) * (C-D) )

Given a Prefix expression, convert it into a Infix expression.
Computers usually does the computation in either prefix or postfix (usually postfix). But for humans, its easier to understand an Infix expression rather than a prefix. Hence conversion is need for human understanding.

Examples:

```Input :  Prefix :  *+AB-CD
Output : Infix : ((A+B)*(C-D))

Input :  Prefix :  *-A/BC-/AKL
Output : Infix : ((A-(B/C))*((A/K)-L))
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Algorithm for Prefix to Infix:

• Read the Prefix expression in reverse order (from right to left)
• If the symbol is an operand, then push it onto the Stack
• If the symbol is an operator, then pop two operands from the Stack
Create a string by concatenating the two operands and the operator between them.
string = (operand1 + operator + operand2)
And push the resultant string back to Stack
• Repeat the above steps until end of Prefix expression.

 `// CPP Program to convert prefix to Infix ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// function to check if character is operator or not ` `bool` `isOperator(``char` `x) { ` `  ``switch` `(x) { ` `  ``case` `'+'``: ` `  ``case` `'-'``: ` `  ``case` `'/'``: ` `  ``case` `'*'``: ` `    ``return` `true``; ` `  ``} ` `  ``return` `false``; ` `} ` ` `  `// Convert prefix to Infix expression ` `string preToInfix(string pre_exp) { ` `  ``stack s; ` ` `  `  ``// length of expression ` `  ``int` `length = pre_exp.size(); ` ` `  `  ``// reading from right to left ` `  ``for` `(``int` `i = length - 1; i >= 0; i--) { ` ` `  `    ``// check if symbol is operator ` `    ``if` `(isOperator(pre_exp[i])) { ` ` `  `      ``// pop two operands from stack ` `      ``string op1 = s.top();   s.pop(); ` `      ``string op2 = s.top();   s.pop(); ` ` `  `      ``// concat the operands and operator ` `      ``string temp = ``"("` `+ op1 + pre_exp[i] + op2 + ``")"``; ` ` `  `      ``// Push string temp back to stack ` `      ``s.push(temp); ` `    ``} ` ` `  `    ``// if symbol is an operand ` `    ``else` `{ ` ` `  `      ``// push the operand to the stack ` `      ``s.push(string(1, pre_exp[i])); ` `    ``} ` `  ``} ` ` `  `  ``// Stack now contains the Infix expression ` `  ``return` `s.top(); ` `} ` ` `  `// Driver Code ` `int` `main() { ` `  ``string pre_exp = ``"*-A/BC-/AKL"``; ` `  ``cout << ``"Infix : "` `<< preToInfix(pre_exp); ` `  ``return` `0; ` `} `

Output:

```Infix : ((A-(B/C))*((A/K)-L))
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.