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:
// 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<string> 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 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
# 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# 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 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.)