Open in App
Not now

Prefix to Infix Conversion

• Difficulty Level : Easy
• Last Updated : 03 Aug, 2022

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))```

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 the end of Prefix expression.
• At the end stack will have only 1 string i.e resultant string

Implementation:

C++

 `// C++ 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` `'*'``:` `  ``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;` `}`

Java

 `// Java program to convert prefix to Infix ` `import` `java.util.Stack;`   `class` `GFG{`   `// Function to check if character` `// is operator or not     ` `static`    `boolean` `isOperator(``char` `x) ` `{` `    ``switch``(x)` `    ``{` `        ``case` `'+'``:` `        ``case` `'-'``:` `        ``case` `'*'``:` `        ``case` `'/'``:` `        ``case` `'^'``:` `        ``case` `'%'``:` `            ``return` `true``;` `    ``}` `    ``return` `false``;` `}`   `// Convert prefix to Infix expression ` `public` `static` `String convert(String str)` `{` `    ``Stack stack = ``new` `Stack<>();` `    `  `    ``// Length of expression ` `    ``int` `l = str.length();` `    `  `    ``// Reading from right to left ` `    ``for``(``int` `i = l - ``1``; i >= ``0``; i--)` `    ``{` `        ``char` `c = str.charAt(i);` `        ``if` `(isOperator(c))` `        ``{` `            ``String op1 = stack.pop();` `            ``String op2 = stack.pop();` `            `  `            ``// Concat the operands and operator ` `            ``String temp = ``"("` `+ op1 + c + op2 + ``")"``;` `            ``stack.push(temp);` `        ``} ` `        ``else` `        ``{` `            `  `            ``// To make character to string` `            ``stack.push(c + ``""``); ` `        ``}` `    ``}` `    ``return` `stack.pop();` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``String exp = ``"*-A/BC-/AKL"``;` `    ``System.out.println(``"Infix : "` `+ convert(exp));` `}` `}`   `// This code is contributed by abbeyme`

Python3

 `# Python Program to convert prefix to Infix` `def` `prefixToInfix(prefix):` `    ``stack ``=` `[]` `    `  `    ``# read prefix in reverse order` `    ``i ``=` `len``(prefix) ``-` `1` `    ``while` `i >``=` `0``:` `        ``if` `not` `isOperator(prefix[i]):` `            `  `            ``# symbol is operand` `            ``stack.append(prefix[i])` `            ``i ``-``=` `1` `        ``else``:` `          `  `            ``# symbol is operator` `            ``str` `=` `"("` `+` `stack.pop() ``+` `prefix[i] ``+` `stack.pop() ``+` `")"` `            ``stack.append(``str``)` `            ``i ``-``=` `1` `    `  `    ``return` `stack.pop()`   `def` `isOperator(c):` `    ``if` `c ``=``=` `"*"` `or` `c ``=``=` `"+"` `or` `c ``=``=` `"-"` `or` `c ``=``=` `"/"` `or` `c ``=``=` `"^"` `or` `c ``=``=` `"("` `or` `c ``=``=` `")"``:` `        ``return` `True` `    ``else``:` `        ``return` `False`   `# Driver code` `if` `__name__``=``=``"__main__"``:` `    ``str` `=` `"*-A/BC-/AKL"` `    ``print``(prefixToInfix(``str``))` `    `  `# This code is contributed by avishekarora`

C#

 `// C# program to convert prefix to Infix ` `using` `System;` `using` `System.Collections;`   `class` `GFG{` ` `  `// Function to check if character` `// is operator or not     ` `static` `bool` `isOperator(``char` `x) ` `{` `    ``switch``(x)` `    ``{` `        ``case` `'+'``:` `        ``case` `'-'``:` `        ``case` `'*'``:` `        ``case` `'/'``:` `        ``case` `'^'``:` `        ``case` `'%'``:` `            ``return` `true``;` `    ``}` `    ``return` `false``;` `}` ` `  `// Convert prefix to Infix expression ` `public` `static` `string` `convert(``string` `str)` `{` `    ``Stack stack = ``new` `Stack();` `     `  `    ``// Length of expression ` `    ``int` `l = str.Length;` `     `  `    ``// Reading from right to left ` `    ``for``(``int` `i = l - 1; i >= 0; i--)` `    ``{` `        ``char` `c = str[i];` `        `  `        ``if` `(isOperator(c))` `        ``{` `            ``string` `op1 = (``string``)stack.Pop();` `            ``string` `op2 = (``string``)stack.Pop();` `             `  `            ``// Concat the operands and operator ` `            ``string` `temp = ``"("` `+ op1 + c + op2 + ``")"``;` `            ``stack.Push(temp);` `        ``} ` `        ``else` `        ``{` `            `  `            ``// To make character to string` `            ``stack.Push(c + ``""``); ` `        ``}` `    ``}` `    ``return` `(``string``)stack.Pop();` `}` ` `  `// Driver code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``string` `exp = ``"*-A/BC-/AKL"``;` `    `  `    ``Console.Write(``"Infix : "` `+ convert(exp));` `}` `}`   `// This code is contributed by rutvik_56`

Javascript

 ``

Output

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

Time Complexity: O(n)
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up
Related Articles