Convert Infix To Prefix Notation

Last Updated : 03 Feb, 2025

Given an infix expression consisting of operators (+, -, *, /, ^) and operands (lowercase characters), the task is to convert it to a prefix expression.

Infix Expression: The expression of type a 'operator' b (a+b, where + is an operator) i.e., when the operator is between two operands.
Prefix Expression: The expression of type 'operator' a b (+ab where + is an operator) i.e., when the operator is placed before the operands.

Examples:

Input: a*b+c/d
Output: +*ab/cd
Input: (a-b/c)*(a/k-l)
Output: *-a/bc-/akl

Approach:

The idea is to first reverse the given infix expression while swapping '(' with ')' and vice versa, then convert this modified expression to postfix notation using a stack-based approach that follows operator precedence and associativity rules, and finally reverse the obtained postfix expression to get the prefix notation.

Step by step approach:

Reverse the infix expression. Note while reversing each '(' will become ')' and each ')' becomes '('.
Convert the reversed infix expression to postfix expression.
- Initialize an empty stack to store operators and an empty string for the postfix expression.
- Scan the infix expression from left to right.
- If the character is an operand, append it to the postfix expression.
- If the character is '(', push it onto the stack.
- If the character is ')', pop from the stack and append to the postfix expression until '(' is found, then pop '(' without appending.
- If the character is an operator, pop and append operators from the stack until the stack is empty or a lower precedence operator is found, then push the current operator onto the stack.
- After scanning the expression, pop and append all remaining operators from the stack to the postfix expression.
Reverse the postfix expression and return it.

Illustration:

See the below image for a clear idea:

Convert infix expression to prefix expression

Below is implementation of the above approach:

C++

// C++ program to convert infix to prefix
#include <bits/stdc++.h>
using namespace std;

// Check if character is an operator
bool isOperator(char ch) {
    return (ch == '+' || ch == '-' || 
    ch == '*' || ch == '/' || ch == '^');
}

// Get precedence of operators
int operatorPrecedence(char op) {
    if (op == '^') return 3;
    if (op == '*' || op == '/') return 2;
    if (op == '+' || op == '-') return 1;
    return -1;
}

// Convert infix expression to postfix notation
string convertInfixToPostfix(string s) {
    stack<char> st;
    string res;
    int sz = s.size();

    for (int i = 0; i < sz; i++) {
        if (isalnum(s[i])) {
            res += s[i];
        } else if (s[i] == '(') {
            st.push(s[i]);
        } else if (s[i] == ')') {
            while (!st.empty() && st.top() != '(') {
                res += st.top();
                st.pop();
            }
            st.pop();
        } else {
            while (!st.empty() && operatorPrecedence(s[i]) <= 
            operatorPrecedence(st.top())) {
                res += st.top();
                st.pop();
            }
            st.push(s[i]);
        }
    }

    while (!st.empty()) {
        res += st.top();
        st.pop();
    }

    return res;
}

// Convert infix expression to prefix notation
string convertToPrefix(string infix) {
    reverse(infix.begin(), infix.end());

    for (int i = 0; i < infix.size(); i++) {
        if (infix[i] == '(') {
            infix[i] = ')';
        } else if (infix[i] == ')') {
            infix[i] = '(';
        }
    }

    string postfix = convertInfixToPostfix(infix);
    reverse(postfix.begin(), postfix.end());

    return postfix;
}

int main() {
    string s = "(a-b/c)*(a/k-l)";
    cout << convertToPrefix(s) << endl;
    return 0;
}

Java

// Java program to convert infix to prefix
import java.util.*;

class GfG {

    // Check if character is an operator
    static boolean isOperator(char ch) {
        return (ch == '+' || ch == '-' || 
                ch == '*' || ch == '/' || ch == '^');
    }

    // Get precedence of operators
    static int operatorPrecedence(char op) {
        if (op == '^') return 3;
        if (op == '*' || op == '/') return 2;
        if (op == '+' || op == '-') return 1;
        return -1;
    }

    // Convert infix expression to postfix notation
    static String convertInfixToPostfix(String s) {
        Stack<Character> st = new Stack<>();
        StringBuilder res = new StringBuilder();
        int sz = s.length();

        for (int i = 0; i < sz; i++) {
            if (Character.isLetterOrDigit(s.charAt(i))) {
                res.append(s.charAt(i));
            } else if (s.charAt(i) == '(') {
                st.push(s.charAt(i));
            } else if (s.charAt(i) == ')') {
                while (!st.isEmpty() && st.peek() != '(') {
                    res.append(st.pop());
                }
                st.pop();
            } else {
                while (!st.isEmpty() && operatorPrecedence(s.charAt(i)) <= 
                operatorPrecedence(st.peek())) {
                    res.append(st.pop());
                }
                st.push(s.charAt(i));
            }
        }

        while (!st.isEmpty()) {
            res.append(st.pop());
        }

        return res.toString();
    }

    // Convert infix expression to prefix notation
    static String convertToPrefix(String infix) {
        StringBuilder sb = new StringBuilder(infix);
        sb.reverse();
        infix = sb.toString();

        char[] chars = infix.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == '(') {
                chars[i] = ')';
            } else if (chars[i] == ')') {
                chars[i] = '(';
            }
        }

        String postfix = convertInfixToPostfix(new String(chars));
        return new StringBuilder(postfix).reverse().toString();
    }

    public static void main(String[] args) {
        String s = "(a-b/c)*(a/k-l)";
        System.out.println(convertToPrefix(s));
    }
}

Python

# Python program to convert infix to prefix

# Check if character is an operator
def isOperator(ch):
    return ch in ['+', '-', '*', '/', '^']

# Get precedence of operators
def operatorPrecedence(op):
    if op == '^':
        return 3
    if op in ['*', '/']:
        return 2
    if op in ['+', '-']:
        return 1
    return -1

# Convert infix expression to postfix notation
def convertInfixToPostfix(s):
    st = []
    res = ""
    sz = len(s)

    for i in range(sz):
        if s[i].isalnum():
            res += s[i]
        elif s[i] == '(':
            st.append(s[i])
        elif s[i] == ')':
            while st and st[-1] != '(':
                res += st.pop()
            st.pop()
        else:
            while st and operatorPrecedence(s[i]) <= operatorPrecedence(st[-1]):
                res += st.pop()
            st.append(s[i])

    while st:
        res += st.pop()

    return res

# Convert infix expression to prefix notation
def convertToPrefix(infix):
    infix = infix[::-1]
    infix = ''.join(['(' if ch == ')' else ')' if ch == '(' else ch for ch in infix])
    
    postfix = convertInfixToPostfix(infix)
    return postfix[::-1]

if __name__ == "__main__":
    s = "(a-b/c)*(a/k-l)"
    print(convertToPrefix(s))

// C# program to convert infix to prefix
using System;
using System.Collections.Generic;

class GfG {

    // Check if character is an operator
    static bool isOperator(char ch) {
        return (ch == '+' || ch == '-' || 
                ch == '*' || ch == '/' || ch == '^');
    }

    // Get precedence of operators
    static int operatorPrecedence(char op) {
        if (op == '^') return 3;
        if (op == '*' || op == '/') return 2;
        if (op == '+' || op == '-') return 1;
        return -1;
    }

    // Convert infix expression to postfix notation
    static string convertInfixToPostfix(string s) {
        Stack<char> st = new Stack<char>();
        string res = "";
        int sz = s.Length;

        for (int i = 0; i < sz; i++) {
            if (char.IsLetterOrDigit(s[i])) {
                res += s[i];
            } else if (s[i] == '(') {
                st.Push(s[i]);
            } else if (s[i] == ')') {
                while (st.Count > 0 && st.Peek() != '(') {
                    res += st.Pop();
                }
                st.Pop();
            } else {
                while (st.Count > 0 && operatorPrecedence(s[i]) <= 
                operatorPrecedence(st.Peek())) {
                    res += st.Pop();
                }
                st.Push(s[i]);
            }
        }

        while (st.Count > 0) {
            res += st.Pop();
        }

        return res;
    }

    // Convert infix expression to prefix notation
    static string convertToPrefix(string infix) {
        char[] arr = infix.ToCharArray();
        Array.Reverse(arr);
        infix = new string(arr);

        for (int i = 0; i < arr.Length; i++) {
            if (arr[i] == '(') {
                arr[i] = ')';
            } else if (arr[i] == ')') {
                arr[i] = '(';
            }
        }

        string postfix = convertInfixToPostfix(new string(arr));
        char[] postArr = postfix.ToCharArray();
        Array.Reverse(postArr);
        return new string(postArr);
    }

    static void Main(string[] args) {
        string s = "(a-b/c)*(a/k-l)";
        Console.WriteLine(convertToPrefix(s));
    }
}

JavaScript

// JavaScript program to convert infix to prefix

// Check if character is an operator
function isOperator(ch) {
    return ['+', '-', '*', '/', '^'].includes(ch);
}

// Get precedence of operators
function operatorPrecedence(op) {
    if (op === '^') return 3;
    if (op === '*' || op === '/') return 2;
    if (op === '+' || op === '-') return 1;
    return -1;
}

// Convert infix expression to postfix notation
function convertInfixToPostfix(s) {
    let st = [];
    let res = "";
    
    for (let i = 0; i < s.length; i++) {
        if (/[a-zA-Z0-9]/.test(s[i])) {
            res += s[i];
        } else if (s[i] === '(') {
            st.push(s[i]);
        } else if (s[i] === ')') {
            while (st.length && st[st.length - 1] !== '(') {
                res += st.pop();
            }
            st.pop();
        } else {
            while (st.length && operatorPrecedence(s[i]) <= operatorPrecedence(st[st.length - 1])) {
                res += st.pop();
            }
            st.push(s[i]);
        }
    }

    while (st.length) {
        res += st.pop();
    }

    return res;
}

// Convert infix expression to prefix notation
function convertToPrefix(infix) {
    let reversed = infix.split("").reverse().join("");
    reversed = reversed.replace(/\(/g, 'X').replace(/\)/g, '(').replace(/X/g, ')');

    let postfix = convertInfixToPostfix(reversed);
    return postfix.split("").reverse().join("");
}

let s = "(a-b/c)*(a/k-l)";
console.log(convertToPrefix(s));

Output

*-a/bc-/akl

Complexity Analysis:

Time Complexity: O(n)
- Stack operations like push() and pop() are performed in constant time.
- Since we scan all the characters in the expression once the complexity is linear in time
Auxiliary Space: O(n) because we are keeping a stack.

Valid Parentheses in an Expression

Sayan Mahapatra

Improve

Article Tags :

Practice Tags :

Convert Infix To Prefix Notation

Similar Reads

Stack implementation in different language

Some questions related to Stack implementation

Easy problems on Stack

Intermediate problems on Stack

Thank You!

What kind of Experience do you want to share?