Postfix to Prefix Conversion (original) (raw)

Last Updated : 14 Aug, 2025

**Postfix: An expression is called the postfix expression if the operator appears in the expression after the operands. Simply of the form (operand1 operand2 operator).
Example : AB+CD-* (Infix : (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) )

Problem Statement

Given a **Postfix expression, convert it into a **Prefix expression.

Instead of converting **Postfix → Infix → Prefix, we can directly convert **Postfix → Prefix.
This method is both efficient (fewer steps) and intuitive, since computers naturally evaluate expressions in Postfix form.

Examples:

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

**Input : Postfix : ABC/-AK/L-*
**Output : Prefix : *-A/BC-/AKL
**Explanation : Postfix to Infix : ((A-(B/C))*((A/K)-L))
Infix to Prefix : *-A/BC-/AKL

Try It Yourself

**Algorithm for Postfix to Prefix:

We use a **stack to build the prefix expression step by step:

Read the Postfix expression from left to right
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 before them.
**string = operator + operand2 + operand1
And push the resultant string back to Stack
Repeat the above steps until end of Postfix expression.

Below is the implementation of the above idea:

C++ `

// CPP Program to convert postfix to prefix #include <bits/stdc++.h> 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 postfix to Prefix expression string postToPre(string post_exp) { stack s;

// length of expression
int length = post_exp.size();

// reading from left to right
for (int i = 0; i < length; i++) {

    // check if symbol is operator
    if (isOperator(post_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 = post_exp[i] + op2 + op1;

        // 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, post_exp[i]));
    }
}

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

}

// Driver Code int main() { string post_exp = "ABC/-AK/L-*";

// Function call
cout << "Prefix : " << postToPre(post_exp);
return 0;

}

Java

// Java Program to convert postfix to prefix import java.util.*;

class GFG {

// function to check if character
// is operator or not
static boolean isOperator(char x)
{

    switch (x) {
    case '+':
    case '-':
    case '/':
    case '*':
        return true;
    }
    return false;
}

// Convert postfix to Prefix expression
static String postToPre(String post_exp)
{
    Stack<String> s = new Stack<String>();

    // length of expression
    int length = post_exp.length();

    // reading from right to left
    for (int i = 0; i < length; i++) {

        // check if symbol is operator
        if (isOperator(post_exp.charAt(i))) {

            // pop two operands from stack
            String op1 = s.peek();
            s.pop();
            String op2 = s.peek();
            s.pop();

            // concat the operands and operator
            String temp
                = post_exp.charAt(i) + op2 + op1;

            // Push String temp back to stack
            s.push(temp);
        }

        // if symbol is an operand
        else {

            // push the operand to the stack
            s.push(post_exp.charAt(i) + "");
        }
    }

    // concatenate all strings in stack and return the
    // answer
    String ans = "";
    for (String i : s)
        ans += i;
    return ans;
}

// Driver Code
public static void main(String args[])
{
    String post_exp = "ABC/-AK/L-*";

    // Function call
    System.out.println("Prefix : "
                       + postToPre(post_exp));
}

}

// This code is contributed by Arnab Kundu

Python

Python3 Program to convert postfix to prefix

function to check if

character is operator or not

def isOperator(x):

if x == "+":
    return True

if x == "-":
    return True

if x == "/":
    return True

if x == "*":
    return True

return False

Convert postfix to Prefix expression

def postToPre(post_exp):

s = []

# length of expression
length = len(post_exp)

# reading from right to left
for i in range(length):

    # check if symbol is operator
    if (isOperator(post_exp[i])):

        # pop two operands from stack
        op1 = s[-1]
        s.pop()
        op2 = s[-1]
        s.pop()

        # concat the operands and operator
        temp = post_exp[i] + op2 + op1

        # Push string temp back to stack
        s.append(temp)

    # if symbol is an operand
    else:

        # push the operand to the stack
        s.append(post_exp[i])


ans = ""
for i in s:
    ans += i
return ans

Driver Code

if name == "main":

post_exp = "AB+CD-"

# Function call
print("Prefix : ", postToPre(post_exp))

This code is contributed by AnkitRai01

C#

// C# Program to convert postfix to prefix using System; using System.Collections;

class GFG {

// function to check if character
// is operator or not
static Boolean isOperator(char x)
{

    switch (x) {
    case '+':
    case '-':
    case '/':
    case '*':
        return true;
    }
    return false;
}

// Convert postfix to Prefix expression
static String postToPre(String post_exp)
{
    Stack s = new Stack();

    // length of expression
    int length = post_exp.Length;

    // reading from right to left
    for (int i = 0; i < length; i++) {

        // check if symbol is operator
        if (isOperator(post_exp[i])) {

            // Pop two operands from stack
            String op1 = (String)s.Peek();
            s.Pop();
            String op2 = (String)s.Peek();
            s.Pop();

            // concat the operands and operator
            String temp = post_exp[i] + op2 + op1;

            // Push String temp back to stack
            s.Push(temp);
        }

        // if symbol is an operand
        else {

            // Push the operand to the stack
            s.Push(post_exp[i] + "");
        }
    }

    String ans = "";
    while (s.Count > 0)
        ans += s.Pop();
    return ans;
}

// Driver Code
public static void Main(String[] args)
{
    String post_exp = "ABC/-AK/L-*";
  
    // Function call
    Console.WriteLine("Prefix : "
                      + postToPre(post_exp));
}

}

// This code is contributed by Arnab Kundu

JavaScript

// JavaScript Program to convert postfix to prefix function isOperator(x) { switch (x) { case '+': case '-': case '/': case '*': return true; } return false; }

// Convert postfix to prefix expression function postToPre(post_exp) { let s = [];

// Length of expression
let length = post_exp.length;

// Reading from left to right
for (let i = 0; i < length; i++) {
    // Check if symbol is an operator
    if (isOperator(post_exp[i])) {
        // Pop two operands from stack
        let op1 = s.pop();
        let op2 = s.pop();

        // Concatenate the operands and operator
        let temp = post_exp[i] + op2 + op1;

        // Push result back to stack
        s.push(temp);
    } else {
        // Push the operand to the stack
        s.push(post_exp[i] + "");
    }
}

// Final prefix expression is the last remaining element in the stack
return s.pop();

}

let post_exp = "ABC/-AK/L-*";

// Function call console.log("Prefix:", postToPre(post_exp));

Output

Prefix : *-A/BC-/AKL

**Time Complexity: O(N)
(We traverse the expression once, each operation is constant time.)
**Auxiliary Space: O(N)
(Stack stores up to N elements in the worst case.)