Convert Infix To Prefix Notation

23 Jun, 2022
While we use infix expressions in our day to day lives. Computers have trouble understanding this format because they need to keep in mind rules of operator precedence and also brackets. Prefix and Postfix expressions are easier for a computer to understand and evaluate. Given two operands and and an operator , the infix notation implies that O will be placed in between a and b i.e . When the operator is placed after both operands i.e , it is called postfix notation. And when the operator is placed before the operands i.e , the expression in prefix notation.Given any infix expression, we can obtain the equivalent prefix and postfix format.
Examples: 
Input : A * B + C / D
Output : + * A B/ C D 

Input : (A - B/C) * (A/K-L)
Output : *-A/BC-/AKL
To convert an infix to postfix expression refer to this article Stack | Set 2 (Infix to Postfix). We use the same to convert Infix to Prefix.
Step 1: Reverse the infix expression i.e A+B*C will become C*B+A. Note while reversing each ‘(‘ will become ‘)’ and each ‘)’ becomes ‘(‘.
Step 2: Obtain the “nearly” postfix expression of the modified expression i.e CB*A+.
Step 3: Reverse the postfix expression. Hence in our example prefix is +A*BC.
Note that for Step 2, we don’t use the postfix algorithm as it is. There is a minor change in the algorithm. As per https://www.geeksforgeeks.org/stack-set-2-infix-to-postfix/ , we have to pop all the operators from the stack which are greater than or equal to in precedence than that of the scanned operator. But here, we have to pop all the operators from the stack which are greater in precedence than that of the scanned operator. Only in the case of “^” operator, we pop operators from the stack which are greater than or equal to in precedence.
Below is the C++ implementation of the algorithm. 
C++
Java
C#
// CPP program to convert infix to prefix#include <bits/stdc++.h>using namespace std; bool isOperator(char c){    return (!isalpha(c) && !isdigit(c));} int getPriority(char C){    if (C == '-' || C == '+')        return 1;    else if (C == '*' || C == '/')        return 2;    else if (C == '^')        return 3;    return 0;} string infixToPostfix(string infix){    infix = '(' + infix + ')';    int l = infix.size();    stack<char> char_stack;    string output;     for (int i = 0; i < l; i++) {         // If the scanned character is an        // operand, add it to output.        if (isalpha(infix[i]) || isdigit(infix[i]))            output += infix[i];         // If the scanned character is an        // ‘(‘, push it to the stack.        else if (infix[i] == '(')            char_stack.push('(');         // If the scanned character is an        // ‘)’, pop and output from the stack        // until an ‘(‘ is encountered.        else if (infix[i] == ')') {            while (char_stack.top() != '(') {                output += char_stack.top();                char_stack.pop();            }             // Remove '(' from the stack            char_stack.pop();        }         // Operator found        else        {            if (isOperator(char_stack.top()))            {                if(infix[i] == '^')                {                      while (getPriority(infix[i]) <= getPriority(char_stack.top()))                       {                         output += char_stack.top();                         char_stack.pop();                       }                                     }                else                {                    while (getPriority(infix[i]) < getPriority(char_stack.top()))                       {                         output += char_stack.top();                         char_stack.pop();                       }                                     }                 // Push current Operator on stack                char_stack.push(infix[i]);            }        }    }      while(!char_stack.empty()){          output += char_stack.top();        char_stack.pop();    }    return output;} string infixToPrefix(string infix){    /* Reverse String     * Replace ( with ) and vice versa     * Get Postfix     * Reverse Postfix  *  */    int l = infix.size();     // Reverse infix    reverse(infix.begin(), infix.end());     // Replace ( with ) and vice versa    for (int i = 0; i < l; i++) {         if (infix[i] == '(') {            infix[i] = ')';        }        else if (infix[i] == ')') {            infix[i] = '(';        }    }     string prefix = infixToPostfix(infix);     // Reverse postfix    reverse(prefix.begin(), prefix.end());     return prefix;} // Driver codeint main(){    string s = ("x+y*z/w+u");    cout << infixToPrefix(s) << std::endl;    return 0;}
// JAVA program to convert infix to prefiximport java.util.*; class GFG{  static boolean isalpha(char c)  {    if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')    {      return true;    }    return false;  }   static boolean isdigit(char c)  {    if (c >= '0' && c <= '9')    {      return true;    }    return false;  }   static boolean isOperator(char c)  {    return (!isalpha(c) && !isdigit(c));  }   static int getPriority(char C)  {    if (C == '-' || C == '+')      return 1;    else if (C == '*' || C == '/')      return 2;    else if (C == '^')      return 3;     return 0;  }   // Reverse the letters of the word  static String reverse(char str[], int start, int end)  {     // Temporary variable to store character    char temp;    while (start < end)    {       // Swapping the first and last character      temp = str[start];      str[start] = str[end];      str[end] = temp;      start++;      end--;    }    return String.valueOf(str);  }   static String infixToPostfix(char[] infix1)  {    System.out.println(infix1);    String infix = '(' + String.valueOf(infix1) + ')';     int l = infix.length();    Stack<Character> char_stack = new Stack<>();    String output="";     for (int i = 0; i < l; i++)    {       // If the scanned character is an      // operand, add it to output.      if (isalpha(infix.charAt(i)) || isdigit(infix.charAt(i)))        output += infix.charAt(i);       // If the scanned character is an      // ‘(‘, push it to the stack.      else if (infix.charAt(i) == '(')        char_stack.add('(');       // If the scanned character is an      // ‘)’, pop and output from the stack      // until an ‘(‘ is encountered.      else if (infix.charAt(i) == ')')      {        while (char_stack.peek() != '(')        {          output += char_stack.peek();          char_stack.pop();        }         // Remove '(' from the stack        char_stack.pop();      }       // Operator found      else {        if (isOperator(char_stack.peek()))        {          while ((getPriority(infix.charAt(i)) <                  getPriority(char_stack.peek()))                 || (getPriority(infix.charAt(i)) <=                     getPriority(char_stack.peek())                     && infix.charAt(i) == '^'))          {            output += char_stack.peek();            char_stack.pop();          }           // Push current Operator on stack          char_stack.add(infix.charAt(i));        }      }    }    while(!char_stack.empty()){          output += char_stack.pop();    }    return output;  }   static String infixToPrefix(char[] infix)  {    /*         * Reverse String Replace ( with ) and vice versa Get Postfix Reverse Postfix *         */    int l = infix.length;     // Reverse infix    String infix1 = reverse(infix, 0, l - 1);    infix = infix1.toCharArray();     // Replace ( with ) and vice versa    for (int i = 0; i < l; i++)    {       if (infix[i] == '(')      {        infix[i] = ')';        i++;      }      else if (infix[i] == ')')      {        infix[i] = '(';        i++;      }    }     String prefix = infixToPostfix(infix);     // Reverse postfix    prefix = reverse(prefix.toCharArray(), 0, l-1);     return prefix;  }   // Driver code  public static void main(String[] args)  {    String s = ("x+y*z/w+u");    System.out.print(infixToPrefix(s.toCharArray()));  }} // This code is contributed by Rajput-Ji
// C# program to convert infix to prefixusing System;using System.Collections.Generic; public class GFG {  static bool isalpha(char c) {    if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') {      return true;    }    return false;  }   static bool isdigit(char c) {    if (c >= '0' && c <= '9') {      return true;    }    return false;  }   static bool isOperator(char c) {    return (!isalpha(c) && !isdigit(c));  }   static int getPriority(char C) {    if (C == '-' || C == '+')      return 1;    else if (C == '*' || C == '/')      return 2;    else if (C == '^')      return 3;     return 0;  }   // Reverse the letters of the word  static String reverse(char []str, int start, int end) {     // Temporary variable to store character    char temp;    while (start < end) {       // Swapping the first and last character      temp = str[start];      str[start] = str[end];      str[end] = temp;      start++;      end--;    }    return String.Join("",str);  }   static String infixToPostfix(char[] infix1) {    String infix = '(' + String.Join("",infix1) + ')';     int l = infix.Length;    Stack<char> char_stack = new Stack<char>();    String output = "";     for (int i = 0; i < l; i++) {       // If the scanned character is an      // operand, add it to output.      if (isalpha(infix[i]) || isdigit(infix[i]))        output += infix[i];       // If the scanned character is an      // ‘(‘, push it to the stack.      else if (infix[i] == '(')        char_stack.Push('(');       // If the scanned character is an      // ‘)’, pop and output from the stack      // until an ‘(‘ is encountered.      else if (infix[i] == ')') {        while (char_stack.Peek() != '(') {          output += char_stack.Peek();          char_stack.Pop();        }         // Remove '(' from the stack        char_stack.Pop();      }       // Operator found      else {        if (isOperator(char_stack.Peek())) {          while ((getPriority(infix[i]) < getPriority(char_stack.Peek()))                 || (getPriority(infix[i]) <= getPriority(char_stack.Peek())                     && infix[i] == '^')) {            output += char_stack.Peek();            char_stack.Pop();          }           // Push current Operator on stack          char_stack.Push(infix[i]);        }      }    }    while (char_stack.Count!=0) {      output += char_stack.Pop();    }    return output;  }   static String infixToPrefix(char[] infix) {    /*         * Reverse String Replace ( with ) and         // vice versa Get Postfix Reverse Postfix *         */    int l = infix.Length;     // Reverse infix    String infix1 = reverse(infix, 0, l - 1);    infix = infix1.ToCharArray();     // Replace ( with ) and vice versa    for (int i = 0; i < l; i++) {       if (infix[i] == '(') {        infix[i] = ')';        i++;      } else if (infix[i] == ')') {        infix[i] = '(';        i++;      }    }     String prefix = infixToPostfix(infix);     // Reverse postfix    prefix = reverse(prefix.ToCharArray(), 0, l - 1);     return prefix;  }   // Driver code  public static void Main(String[] args) {    String s = ("x+y*z/w+u");    Console.Write(infixToPrefix(s.ToCharArray()));  }} // This code is contributed by gauravrajput1
++x/*yzwu

Time Complexity: 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 i.e .
zen716
sandravsnair
Rajput-Ji
jiaxuantw
i_m_inevitable
202051112
shitalpatil94612
GauravRajput1
rohitkavitake3012
expression-evaluation
Stack
Strings
Strings
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.