Convert Infix To Prefix Notation
Humans use infix expressions on a day-to-day basis, but the nature of infix notation means that compound expressions are generally not evaluated in a linear fashion. Conventions governing operator precedence—which includes the use of parentheses—are a means of removing the very likely possibility that a given combination of operators and operands would otherwise give rise to ambiguous expressions, such as 12 ÷ 6 × 3, which could evaluate to either 6 or â…”. Infix expressions are, therefore, not evaluated in a linear, left-to-right fashion, but in an order of priority determined by the laws of operator precedence. This doesn’t lend itself to the way computers generally perform operations: sequentially, and one-at-a-time. Prefix and postfix notations, on the other hand, build compound expressions that are never ambiguous, as they only ever yield a singular possible result that depends solely on the order in which the operators and operands appear in an expression when processed in a linear fashion. Without the added complication of parentheses and other rules of precedence, computers can evaluate prefix and postfix expressions simply as a set of instructions for them to follow in the order they are given.
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++
// 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 code int main() { string s = ( "x+y*z/w+u" ); cout << infixToPrefix(s) << std::endl; return 0; } |
Java
// JAVA program to convert infix to prefix import 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#
// C# program to convert infix to prefix using 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 |
Javascript
// Javascript program to convert infix to prefix // program to implement stack data structure class Stack { constructor() { this .items = []; } // add element to the stack push(element) { return this .items.push(element); } // remove element from the stack pop() { if ( this .items.length > 0) { return this .items.pop(); } } // view the last element top() { return this .items[ this .items.length - 1]; } // check if the stack is empty isEmpty() { return this .items.length == 0; } // the size of the stack size() { return this .items.length; } // empty the stack clear() { this .items = []; } } function isalpha(c) { if ((c >= "a" && c <= "z" ) || (c >= "A" && c <= "Z" )) { return true ; } return false ; } function isdigit(c) { if (c >= "0" && c <= "9" ) { return true ; } return false ; } function isOperator(c) { return !isalpha(c) && !isdigit(c); } function getPriority(C) { if (C == "-" || C == "+" ) return 1; else if (C == "*" || C == "/" ) return 2; else if (C == "^" ) return 3; return 0; } function infixToPostfix(infix) { infix = "(" + infix + ")" ; var l = infix.length; let char_stack = new Stack(); var output = "" ; for ( var 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.isEmpty()) { output += char_stack.top(); char_stack.pop(); } return output; } function infixToPrefix(infix) { /* Reverse String * Replace ( with ) and vice versa * Get Postfix * Reverse Postfix * */ var l = infix.length; // Reverse infix infix = infix.split( "" ).reverse().join( "" ); // Replace ( with ) and vice versa var infixx = infix.split( "" ); for ( var i = 0; i < l; i++) { if (infixx[i] == "(" ) { infixx[i] = ")" ; } else if (infixx[i] == ")" ) { infixx[i] = "(" ; } } infix = infixx.join( "" ); var prefix = infixToPostfix(infix); // Reverse postfix prefix = prefix.split( "" ).reverse().join( "" ); return prefix; } // Driver code var s = "x+y*z/w+u" ; console.log(infixToPrefix(s)); |
Python3
def isOperator(c): return ( not c.isalpha()) and ( not c.isdigit()) def getPriority(c): if c = = '-' or c = = '+' : return 1 elif c = = '*' or c = = '/' : return 2 elif c = = '^' : return 3 return 0 def infixToPostfix(infix): infix = '(' + infix + ')' l = len (infix) char_stack = [] output = "" for i in range (l): if infix[i].isalpha() or infix[i].isdigit(): output + = infix[i] elif infix[i] = = '(' : char_stack.append(infix[i]) elif infix[i] = = ')' : while char_stack[ - 1 ] ! = '(' : output + = char_stack.pop() char_stack.pop() else : if isOperator(char_stack[ - 1 ]): if infix[i] = = '^' : while getPriority(infix[i]) < = getPriority(char_stack[ - 1 ]): output + = char_stack.pop() else : while getPriority(infix[i]) < getPriority(char_stack[ - 1 ]): output + = char_stack.pop() char_stack.append(infix[i]) while len (char_stack) ! = 0 : output + = char_stack.pop() return output def infixToPrefix(infix): l = len (infix) infix = infix[:: - 1 ] for i in range (l): if infix[i] = = '(' : infix[i] = ')' elif infix[i] = = ')' : infix[i] = '(' prefix = infixToPostfix(infix) prefix = prefix[:: - 1 ] return prefix s = "x+y*z/w+u" print (infixToPrefix(s)) |
++x/*yzwu
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 i.e
Auxiliary Space: O(n) due to recursive stack space
Please Login to comment...