Postfix to infix?

infix to postfix 2+3-5/2*(2*15)/100+5

Both are expressions.. a+b is infix ...where operater comes between operands ab+ is postfix..where operator comes at the last

Write and explain a 'C' function to convert the given infix expression to postfix expressionWrite and explain a 'C' function to convert the given infix expression to postfix expression

Infix: "1 + 2" Prefix: "+ 1 2" Postfix: "1 2 +" The difference is where you put the operator: Betweeen (infix), before (prefix) or after (postfix) the arguments you operate on.

infix: old Egyptians/Assirs some thousands year before prefix: Jan Łukasiewicz (Polish Notation) postfix: Burks, Warren, and Wright (Reverse Polish Notation)

Queue is a FIFO(First In First Out) data structure. The main applications of queue data structure are conversion of expressions from infix to postfix and from infix to prefix,evaluation of postfix expressions.

people almost exclusively use infix notation to write mathematical expressions, computer languages almost exclusively allow programmers to use infix notation. However, if a compiler allowed infix expressions into the binary code used in the compiled version of a program, the resulting code would be larger than needed and very inefficient. Because of this, compilers convert infix expressions into postfix notation expressions, which have a much simpler set of rules for expression evaluation. Postfix notation gets its name from the fact that operators in a postfix expression follow the operands that they specify an operation on. Here are some examples of equivalent infix and postfix expressions Infix Notation Postfix Notation 2 + 3 2 3 + 2 + 3 * 6 3 6 * 2 + (2 + 3) * 6 2 3 + 6 * A / (B * C) + D * E - A - C A B C * / D E * + A C * - Where as infix notation expressions need a long list or rules for evaluation, postfix expressions need very few.

(a + b) * c / ((x - y) * z)

You convert an (infix) expression into a postfix expression as part of the process of generating code to evaluate that expression.

it is needed in compiler designing

stack is the basic data structure needed to convert infix notation to postfix

#include<stdio.h> #include<conio.h> #include<string.h> char symbol,s[10]; int F(symbol) { switch(symbol) { case '+': case '-':return 2; case '*': case '/':return 4; case '^': case '$':return 5; case '(':return 0; case '#':return -1; default :return 8; } } int G(symbol) { switch(symbol) { case '+': case '-':return 1; case '*': case '/':return 3; case '^': case '$':return 6; case '(':return 9; case ')':return 0; default: return 7; } } void infix_to_postfix(char infix[],char postfix[]) { int top=-1,j=0,i,symbol; s[++top]='#'; for(i=0;i<strlen(infix);i++) { symbol=infix[i]; while(F(s[top])>G(symbol)) { postfix[j]=s[top--]; j++; } if(F(s[top])!=G(symbol)) s[++top]=symbol; else top--; } while(s[top]!='#') { postfix[j++]=s[top--]; } postfix[j]='\0'; } void main() { char infix[30],postfix[30]; clrscr(); printf("Enter the valid infix expression\n"); scanf("%s",infix); infix_to_postfix(infix, postfix); printf("postfix expression is \n %s", postfix); getch(); }

Hi, Hope the following link helps to answer your question: http://www.spsu.edu/cs/faculty/bbrown/web_lectures/postfix/ Regards, Ansh

/**************************/ /**********cReDo**********/ /*****mchinmay@live.com***/ //C PROGRAM TO CONVERT GIVEN VALID INFIX EXPRESSION INTO POSTFIX EXPRESSION USING STACKS. #include<stdio.h> #include<conio.h> #include<string.h> #define MAX 20 char stack[MAX]; int top=-1; char pop(); void push(char item); int prcd(char symbol) { switch(symbol) { case '+': case '-':return 2; break; case '*': case '/':return 4; break; case '^': case '$':return 6; break; case '(': case ')': case '#':return 1; break; } } int isoperator(char symbol) { switch(symbol) { case '+': case '-': case '*': case '/': case '^': case '$': case '(': case ')':return 1; break; default:return 0; } } void convertip(char infix[],char postfix[]) { int i,symbol,j=0; stack[++top]='#'; for(i=0;i<strlen(infix);i++) { symbol=infix[i]; if(isoperator(symbol)==0) { postfix[j]=symbol; j++; } else{ if(symbol=='(')push(symbol); else if(symbol==')') { while(stack[top]!='(') { postfix[j]=pop(); j++; } pop();//pop out (. } else{ if(prcd(symbol)>prcd(stack[top])) push(symbol); else{ while(prcd(symbol)<=prcd(stack[top])) { postfix[j]=pop(); j++; } push(symbol); }//end of else. }//end of else. }//end of else. }//end of for. while(stack[top]!='#') { postfix[j]=pop(); j++; } postfix[j]='\0';//null terminate string. } void main() { char infix[20],postfix[20]; clrscr(); printf("Enter the valid infix string:\n"); gets(infix); convertip(infix,postfix); printf("The corresponding postfix string is:\n"); puts(postfix); getch(); } void push(char item) { top++; stack[top]=item; } char pop() { char a; a=stack[top]; top--; return a; } //mail me: mchinmay@live.com

public static boolean isOperand(String s) { double a=0; try { a=Double.parseDouble(s); } catch (Exception ignore) { return false; } return true; } public static boolean isOperator(String s) { String operatorList="+-*/"; return operatorList.indexOf(s)>=0; } public static int precedence(String operator) { int precedence=0; if (operator.equals("+")) { precedence=1; } else if (operator.equals("-")) { precedence=1; } else if (operator.equals("*")) { precedence=2; } else if (operator.equals("/")) { precedence=2; } return precedence; } public static String convert(String infix) { java.util.Stack<String> stack=new java.util.Stack<String>(); String postfix=""; String space=" "; java.util.StringTokenizer st=new java.util.StringTokenizer(infix); while (st.hasMoreTokens()) { String token=st.nextToken(); if (isOperand(token)) { postfix += token + space; } else if (token.equals("(")) { stack.push(token); } else if (isOperator(token)) { while (!stack.empty() && precedence(stack.peek())>=precedence(token)) { postfix += stack.pop() + space; } stack.push(token); } else if (token.equals(")")) { while (!stack.peek().equals("(")) { postfix += stack.pop() + space; } stack.pop(); // pop the left parenthesis } } while (!stack.empty()) { postfix += stack.pop() + space; } return postfix; } public static void main(String[] args) throws Exception { String infix="( 6 + 2 ) * 5 - 8 / 4"; // change this line as needed String postfix=convert(infix); System.out.println("infix="+infix); System.out.println("postfix="+postfix); System.out.println("evaluation="+PostfixEvaluator.evaluate(postfix)); } }

Infix Expression : Any expression in the standard form like "2*3-4/5" is an Infix(Inorder) expression. Postfix Expression : The Postfix(Postorder) form of the above expression is "23*45/-". Infix to Postfix Conversion : In normal algebra we use the infix notation like a+b*c. The corresponding postfix notation is abc*+. The algorithm for the conversion is as follows : Scan the Infix string from left to right. Initialise an empty stack. If the scannned character is an operand, add it to the Postfix string. If the scanned character is an operator and if the stack is empty Push the character to stack. If the scanned character is an Operand and the stack is not empty, compare the precedence of the character with the element on top of the stack (topStack). If topStack has higher precedence over the scanned character Pop the stack else Push the scanned character to stack. Repeat this step as long as stack is not empty and topStack has precedence over the character. Repeat this step till all the characters are scanned. (After all characters are scanned, we have to add any character that the stack may have to the Postfix string.) If stack is not empty add topStack to Postfix string and Pop the stack. Repeat this step as long as stack is not empty. Return the Postfix string. Example : Let us see how the above algorithm will be imlemented using an example. Infix String : a+b*c-d Initially the Stack is empty and our Postfix string has no characters. Now, the first character scanned is 'a'. 'a' is added to the Postfix string. The next character scanned is '+'. It being an operator, it is pushed to the stack. Stack Postfix String Next character scanned is 'b' which will be placed in the Postfix string. Next character is '*' which is an operator. Now, the top element of the stack is '+' which has lower precedence than '*', so '*' will be pushed to the stack. Stack Postfix String The next character is 'c' which is placed in the Postfix string. Next character scanned is '-'. The topmost character in the stack is '*' which has a higher precedence than '-'. Thus '*' will be popped out from the stack and added to the Postfix string. Even now the stack is not empty. Now the topmost element of the stack is '+' which has equal priority to '-'. So pop the '+' from the stack and add it to the Postfix string. The '-' will be pushed to the stack. Stack Postfix String Next character is 'd' which is added to Postfix string. Now all characters have been scanned so we must pop the remaining elements from the stack and add it to the Postfix string. At this stage we have only a '-' in the stack. It is popped out and added to the Postfix string. So, after all characters are scanned, this is how the stack and Postfix string will be : Stack Postfix String End result : Infix String : a+b*c-d Postfix String : abc*+d-

Possible. Here's an example: (1+3)*(3+4) 1 3 + 3 4 + *

Infix Expression : Any expression in the standard form like "2*3-4/5" is an Infix(Inorder) expression. Postfix Expression : The Postfix(Postorder) form of the above expression is "23*45/-". Infix to Postfix Conversion : In normal algebra we use the infix notation like a+b*c. The corresponding postfix notation is abc*+. The algorithm for the conversion is as follows : Scan the Infix string from left to right. Initialise an empty stack. If the scannned character is an operand, add it to the Postfix string. If the scanned character is an operator and if the stack is empty Push the character to stack. If the scanned character is an Operand and the stack is not empty, compare the precedence of the character with the element on top of the stack (topStack). If topStack has higher precedence over the scanned character Pop the stack else Push the scanned character to stack. Repeat this step as long as stack is not empty and topStack has precedence over the character. Repeat this step till all the characters are scanned. (After all characters are scanned, we have to add any character that the stack may have to the Postfix string.) If stack is not empty add topStack to Postfix string and Pop the stack. Repeat this step as long as stack is not empty. Return the Postfix string. Example : Let us see how the above algorithm will be imlemented using an example. Infix String : a+b*c-d Initially the Stack is empty and our Postfix string has no characters. Now, the first character scanned is 'a'. 'a' is added to the Postfix string. The next character scanned is '+'. It being an operator, it is pushed to the stack. Stack Postfix String Next character scanned is 'b' which will be placed in the Postfix string. Next character is '*' which is an operator. Now, the top element of the stack is '+' which has lower precedence than '*', so '*' will be pushed to the stack. Stack Postfix String The next character is 'c' which is placed in the Postfix string. Next character scanned is '-'. The topmost character in the stack is '*' which has a higher precedence than '-'. Thus '*' will be popped out from the stack and added to the Postfix string. Even now the stack is not empty. Now the topmost element of the stack is '+' which has equal priority to '-'. So pop the '+' from the stack and add it to the Postfix string. The '-' will be pushed to the stack. Stack Postfix String Next character is 'd' which is added to Postfix string. Now all characters have been scanned so we must pop the remaining elements from the stack and add it to the Postfix string. At this stage we have only a '-' in the stack. It is popped out and added to the Postfix string. So, after all characters are scanned, this is how the stack and Postfix string will be : Stack Postfix String End result : Infix String : a+b*c-d Postfix String : abc*+d-

#include <iostream> #include <cstdlib> #include <cstring> #include <cstdio> #define size 400 using namespace std; char infix[size]="\0",postfix[size]="\0",Stack[size]; int top; int precedence(char ch) { switch(ch) { case '^':return 5; case '/':return 4; case '*':return 4; case '+':return 3; case '-':return 3; default:return 0; } } char Pop() { char ret; if(top!=-1) { ret=Stack[top]; top--; return ret; } else return '#'; } char Topelem() { char ch; if(top!=-1) ch=Stack[top]; else ch='#'; return ch; } void Push(char ch) { if(top!=size-1) { top++; Stack[top]=ch; } } int braces(char* s) { int l,r; l=0;r=0; for(int i=0;s[i];i++) { if(s[i]=='(') l++; if(s[i]==')') r++; } if(l==r) return 0; else if(l<r) return 1; else return -1; } int main() { char ele,elem,st[2]; int T,prep,pre,popped,j=0,chk=0; cin>>T; while(T--) { j=0;chk=0;top=-1; strcpy(postfix," "); cin>>infix; chk=braces(infix); if(chk==0) { for(int i=0;infix[i];i++) { if(infix[i]=='(') { elem=infix[i]; Push(elem); } else if(infix[i]==')') { while((popped=Pop())!='(') { postfix[j++]=popped; } } else if(infix[i]=='^'infix[i]=='/'infix[i]=='*'infix[i]=='+'infix[i]=='-') { elem=infix[i]; pre=precedence(elem); ele=Topelem(); prep=precedence(ele); if(pre>prep) Push(elem); else { while(prep>=pre) { if(ele=='#') break; popped=Pop(); ele=Topelem(); postfix[j++]=popped; prep=precedence(ele); } Push(elem); } } else { postfix[j++]=infix[i]; } } while((popped=Pop())!='#') postfix[j++]=popped; postfix[j]='\0'; cout<<postfix; } } }

/**************************/ /**********cReDo**********/ /*****mchinmay@live.com***/ //C PROGRAM TO CONVERT GIVEN VALID INFIX EXPRESSION INTO POSTFIX EXPRESSION USING STACKS. #include<stdio.h> #include<conio.h> #include<string.h> #define MAX 20 char stack[MAX]; int top=-1; char pop(); void push(char item); int prcd(char symbol) { switch(symbol) { case '+': case '-':return 2; break; case '*': case '/':return 4; break; case '^': case '$':return 6; break; case '(': case ')': case '#':return 1; break; } } int isoperator(char symbol) { switch(symbol) { case '+': case '-': case '*': case '/': case '^': case '$': case '(': case ')':return 1; break; default:return 0; } } void convertip(char infix[],char postfix[]) { int i,symbol,j=0; stack[++top]='#'; for(i=0;i<strlen(infix);i++) { symbol=infix[i]; if(isoperator(symbol)==0) { postfix[j]=symbol; j++; } else{ if(symbol=='(')push(symbol); else if(symbol==')') { while(stack[top]!='(') { postfix[j]=pop(); j++; } pop();//pop out (. } else{ if(prcd(symbol)>prcd(stack[top])) push(symbol); else{ while(prcd(symbol)<=prcd(stack[top])) { postfix[j]=pop(); j++; } push(symbol); }//end of else. }//end of else. }//end of else. }//end of for. while(stack[top]!='#') { postfix[j]=pop(); j++; } postfix[j]='\0';//null terminate string. } void main() { char infix[20],postfix[20]; clrscr(); printf("Enter the valid infix string:\n"); gets(infix); convertip(infix,postfix); printf("The corresponding postfix string is:\n"); puts(postfix); getch(); } void push(char item) { top++; stack[top]=item; } char pop() { char a; a=stack[top]; top--; return a; } //mail me: mchinmay@live.com

# /**************************/ /**********cReDo**********/ /*****mchinmay@live.com***/ //C PROGRAM TO CONVERT GIVEN VALID INFIX EXPRESSION INTO POSTFIX EXPRESSION USING STACKS. #include<stdio.h> #include<conio.h> #include<string.h> #define MAX 20 char stack[MAX]; int top=-1; char pop(); void push(char item); int prcd(char symbol) { switch(symbol) { case '+': case '-':return 2; break; case '*': case '/':return 4; break; case '^': case '$':return 6; break; case '(': case ')': case '#':return 1; break; } } int isoperator(char symbol) { switch(symbol) { case '+': case '-': case '*': case '/': case '^': case '$': case '(': case ')':return 1; break; default:return 0; } } void convertip(char infix[],char postfix[]) { int i,symbol,j=0; stack[++top]='#'; for(i=0;i<strlen(infix);i++) { symbol=infix[i]; if(isoperator(symbol)==0) { postfix[j]=symbol; j++; } else{ if(symbol=='(')push(symbol); else if(symbol==')') { while(stack[top]!='(') { postfix[j]=pop(); j++; } pop();//pop out (. } else{ if(prcd(symbol)>prcd(stack[top])) push(symbol); else{ while(prcd(symbol)<=prcd(stack[top])) { postfix[j]=pop(); j++; } push(symbol); }//end of else. }//end of else. }//end of else. }//end of for. while(stack[top]!='#') { postfix[j]=pop(); j++; } postfix[j]='\0';//null terminate string. } void main() { char infix[20],postfix[20]; clrscr(); printf("Enter the valid infix string:\n"); gets(infix); convertip(infix,postfix); printf("The corresponding postfix string is:\n"); puts(postfix); getch(); } void push(char item) { top++; stack[top]=item; } char pop() { char a; a=stack[top]; top--; return a; } //mail me: mchinmay@live.com

/**************************/ /**********cReDo**********/ /*****mchinmay@live.com***/ //C PROGRAM TO CONVERT GIVEN VALID INFIX EXPRESSION INTO POSTFIX EXPRESSION USING STACKS. #include<stdio.h> #include<conio.h> #include<string.h> #define MAX 20 char stack[MAX]; int top=-1; char pop(); void push(char item); int prcd(char symbol) { switch(symbol) { case '+': case '-':return 2; break; case '*': case '/':return 4; break; case '^': case '$':return 6; break; case '(': case ')': case '#':return 1; break; } } int isoperator(char symbol) { switch(symbol) { case '+': case '-': case '*': case '/': case '^': case '$': case '(': case ')':return 1; break; default:return 0; } } void convertip(char infix[],char postfix[]) { int i,symbol,j=0; stack[++top]='#'; for(i=0;i<strlen(infix);i++) { symbol=infix[i]; if(isoperator(symbol)==0) { postfix[j]=symbol; j++; } else{ if(symbol=='(')push(symbol); else if(symbol==')') { while(stack[top]!='(') { postfix[j]=pop(); j++; } pop();//pop out (. } else{ if(prcd(symbol)>prcd(stack[top])) push(symbol); else{ while(prcd(symbol)<=prcd(stack[top])) { postfix[j]=pop(); j++; } push(symbol); }//end of else. }//end of else. }//end of else. }//end of for. while(stack[top]!='#') { postfix[j]=pop(); j++; } postfix[j]='\0';//null terminate string. } void main() { char infix[20],postfix[20]; clrscr(); printf("Enter the valid infix string:\n"); gets(infix); convertip(infix,postfix); printf("The corresponding postfix string is:\n"); puts(postfix); getch(); } void push(char item) { top++; stack[top]=item; } char pop() { char a; a=stack[top]; top--; return a; } //mail me: mchinmay@live.com

struct stack { char ele; struct stack *next; }; void push(int); int pop(); int precedence(char); struct stack *top = NULL; int main() { char infix[20], postfix[20]; int i=0,j=0; printf("ENTER INFIX EXPRESSION: "); gets(infix); while(infix[i]!='\0') { if(isalnum(infix[i])) postfix[j++]=infix[i]; else { if(top==NULL) push(infix[i]); else { while(top!=NULL && (precedence(top->ele)>=precedence(infix[i]))) postfix[j++]=pop(); push(infix[i]); } } ++i; } while(top!=NULL) postfix[j++]=pop(); postfix[j]='\0'; puts(postfix); getchar(); return 0; } int precedence(char x) { switch(x) { case '^': return 4; case '*': case '/': return 3; case '+': case '-': return 2; default: return 0; } } void push(int x) { int item; struct stack *tmp; if(top==NULL) { top=(struct stack *)malloc(sizeof(struct stack)); top->ele=x; top->next=NULL; } else { tmp=top; top->ele=x; top->next=tmp; } } int pop() { struct stack *tmp; int item; if(top==NULL) puts("EMPTY STACK"); else if(top->next==NULL) { tmp=top; item=top->ele; top=NULL; free(tmp); } else { tmp=top; item=top->ele; top=top->next; free(tmp); } return item; }

Example: prefix: * 2 + 3 4 infix: 2 * (3+4) postfix: 2 3 4 + *

An algorithm can not be written with the following infix expression without knowing what the expression is. Once this information is included a person will be able to know how to write the algorithm.