Open In App
Related Articles

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

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)