A

Micro project report On

“A PROJECT TO CONVERT ARITHMATIC EXPRESSION INTO

PREFIX,POSTFIX OR INFIX”

SUBMITTED TO M.S.B.T.E., Mumbai

For the Award of

DIPLOMA IN COMPUTER ENGINEERING BY

Roll no Name of Student Enrollment no

Shaikh Riyaz Shafik

25 Taher Amjad Tamboli 23213300192

22 Siddeki Asifraja Ismail 23213300191

13 Shaikh Taushik Amin 23213300189

UNDER THE GUIDANCE OF

MR ANIL
DEPARTMENT OF COMPUTER
ENGINEERING

MAULANA AZAD POLYTECHNIC,

Gat No 36/1 a, At Hotgi, Tal.
South Solapur, hotgi, Hotgi Rd, Solapur,
Maharashtra 413006.
2023-24

AFFILIATED TO M.S.B.T.E.
Evolution sheet for Micro Project

Academic Year:- 2023-24 Name of Faculty:-

MR ANIL
Course:- Computer Engineering Course code:-
CO3I
Subject:- DSU Subject Code:-
22317
Semester:- 3 Scheme:- I

Title of A PROJECT TO CONVERT ARITHMATIC

Project:- EXPRESSION INTO PREFIX,POSTFIX OR INFIX
COs addressed by the Micro Project:

Comments/Suggestions about team work/leadership/inter-personal

communication (if any)
Marks out
Marks out Tota
of 4 for
of 6 for l
Roll No Name of students performanc
performanc mars
e in oral/
e in group out
Presentation
activity of 10
Shaikh Riyaz Shafik
25 Taher Amjad
Tamboli
Siddeki Asifraja Ismail
13 Shaikh Taushik Amin

Name and
Signatur MR ANIL
e of
faculty
 MAULANA AZAD POLYTECHNIC , SOLAPUR

CERTIFICATE

This is to certify that the Project report entitled

“A PROJECT TO CONVERT ARITHMATIC EXPRESSION INTO PREFIX,POSTFIX

OR INFIX”
Submitted by

Roll no Name of Student Enrollment no

Shaikh Riyaz Shafik

25 Taher Amjad Tamboli 23213300192

22 Siddeki Asifraja Ismail 23213300191

13 Shaikh Taushik Amin 23213300189

This is a bonafide work carried out by above students, under the guidance of MR
ANIL and it is submitted towards the fulfillment of requirement of MSBTE, Mumbai for
the award of Diploma Computer Engineering at MAULANA AZAD POLYTECHNIC ,
SOLAPUR during the academic year 2023-2024.

(MR ANIL)
Guide
(Ms.Asma Tamboli) (Mr.S.N.Shah)
HOD Principal

Place:
Date:

Infix To Postfix Conversion Using Stack [with

C program]
Infix to Postfix Conversion in C: In this tutorial, we will learn how to
convert Infix to Postfix using stack with the help of C program.

Overview
One of the applications of Stack is in the conversion of arithmetic
expressions in high-level programming languages into machine
readable form. As our computer system can only understand and work
on a binary language, it assumes that an arithmetic operation can take
place in two operands only e.g., A+B, C*D,D/A etc. But in our usual
form an arithmetic expression may consist of more than one operator
and two operands e.g. (A+B)*C(D/(J+D)).

These complex arithmetic operations can be converted into polish

notation using stacks which then can be executed in two operands and
an operator form.

What is an Infix Expression?

It follows the scheme of <operand><operator><operand> i.e. an
<operator> is preceded and succeeded by an <operand>. Such an
expression is termed infix expression. E.g., A+B

What is a Postfix Expression?

It follows the scheme of <operand><operand><operator> i.e. an
<operator> is succeeded by both the <operand>. E.g., AB+

Algorithm to Convert Infix to Postfix

Expression
The following are the steps (algorithm) to convert an infix expression
to a postfix expression:

1. Let, X is an arithmetic expression written in infix notation.

2. Push "("onto Stack, and add ")" to the end of X.
3. Scan X from left to right and repeat Step 3 to 6 for each element
of X until the Stack is empty.
4. If an operand is encountered, add it to Y.
5. If a left parenthesis is encountered, push it onto Stack.
6. If an operator is encountered ,then:
1. Repeatedly pop from Stack and add to Y each operator (on
the top of Stack) which has the same precedence as or
higher precedence than operator.
2. Add operator to Stack.
[End of If]
7. If a right parenthesis is encountered ,then:
1. Repeatedly pop from Stack and add to Y each operator (on
the top of Stack) until a left parenthesis is encountered.
2. Remove the left Parenthesis.
[End of If]
[End of If]
8. END.

Example of Infix to Postfix Conversion

Let's take an example to better understand the algorithm

Infix Expression: A+(B*C-(D/E^F)*G)*H, where ^ is an

exponential operator.

Step by step output for infix to postfix conversion

Input String Output Stack Operator Stack
A+(B*C-(D/E^F)*G)*H
A+(B*C-(D/E^F)*G)*H A
A+(B*C-(D/E^F)*G)*H A +
A+(B*C-(D/E^F)*G)*H A +(
A+(B*C-(D/E^F)*G)*H AB +(
A+(B*C-(D/E^F)*G)*H AB +(*
 Input String Output Stack Operator Stack
A+(B*C-(D/E^F)*G)*H ABC +(*
A+(B*C-(D/E^F)*G)*H ABC* +(-
A+(B*C-(D/E^F)*G)*H ABC* +(-(
A+(B*C-(D/E^F)*G)*H ABC*D +(-(
A+(B*C-(D/E^F)*G)*H ABC*D +(-(/
A+(B*C-(D/E^F)*G)*H ABC*DE +(-(/
A+(B*C-(D/E^F)*G)*H ABC*DE +(-(/^
A+(B*C-(D/E^F)*G)*H ABC*DEF +(-(/^
A+(B*C-(D/E^F)*G)*H ABC*DEF^/ +(-
A+(B*C-(D/E^F)*G)*H ABC*DEF^/ +(-*
A+(B*C-(D/E^F)*G)*H ABC*DEF^/G +(-*
A+(B*C-(D/E^F)*G)*H ABC*DEF^/G*- +
A+(B*C-(D/E^F)*G)*H ABC*DEF^/G*- +*
A+(B*C-(D/E^F)*G)*H ABC*DEF^/G*-H +*
A+(B*C-(D/E^F)*G)*H ABC*DEF^/G*-H*+

Advantage of Postfix Expression over Infix

Expression:-
Resultant Postfix Expression: ABC*DEF^/G*-H*+

Advantage of Postfix Expression over Infix Expression

An infix expression is difficult for the machine to know and keep track
of precedence of operators. On the other hand, a postfix expression
itself determines the precedence of operators (as the placement of
operators in a postfix expression depends upon its
precedence).Therefore, for the machine it is easier to carry out a
postfix expression than an infix expression.
C Program to Convert Infix to Postfix Expression
/* This program converts infix expression to postfix
expression.
* This program assume that there are Five operators: (*, /,
+, -,^)
in infix expression and operands can be of single-
digit only.
* This program will not work for fractional numbers.
* Further this program does not check whether infix
expression is
valid or not in terms of number of operators and
operands.*/

#include <stdio.h>
#include <stdlib.h> /* for exit() */
#include <ctype.h> /* for isdigit(char ) */
#include <string.h>

#define SIZE 100

/* declared here as global variable because stack[]

* is used by more than one fucntions */
char stack[SIZE];
int top = -1;

/* define push operation */

void push(char item)

{
if (top >= SIZE - 1) {
printf("\nStack Overflow.");
}
else {
top = top + 1;
stack[top] = item;
}
}

/* define pop operation */

char pop()
{
 char item;

if (top < 0) {
printf("stack under flow: invalid infix
expression");
getchar();
/* underflow may occur for invalid expression */
/* where ( and ) are not matched */
exit(1);
}
else {
item = stack[top];
top = top - 1;
return (item);
}
}

/* define function that is used to determine whether any

symbol is operator or not
(that is symbol is operand)
* this fucntion returns 1 if symbol is opreator else return
0 */

int is_operator(char symbol)

{
if (symbol == '^' || symbol == '*' || symbol == '/' ||
symbol == '+' || symbol == '-') {
return 1;
}
else {
return 0;
}
}

/* define fucntion that is used to assign precendence to

operator.
* Here ^ denotes exponent operator.
* In this fucntion we assume that higher integer value
* means higher precendence */

int precedence(char symbol)

{
 if (symbol == '^') /* exponent operator, highest
precedence*/
{
return (3);
}
else if (symbol == '*' || symbol == '/') {
return (2);
}
else if (symbol == '+' || symbol == '-') /* lowest
precedence */
{
return (1);
}
else {
return (0);
}
}

void InfixToPostfix(char infix_exp[], char postfix_exp[])

{
int i, j;
char item;
char x;

push('('); /* push '(' onto stack */

strcat(infix_exp, ")"); /* add ')' to infix expression
*/

i = 0;
j = 0;
item = infix_exp[i]; /* initialize before loop*/

while (item != '\0') /* run loop till end of infix

expression */
{
if (item == '(') {
push(item);
}
else if (isdigit(item) || isalpha(item)) {
postfix_exp[j] = item; /* add operand symbol to
postfix expr */
j++;
}
 else if (is_operator(item) == 1) /* means symbol is
operator */
{
x = pop();
while (is_operator(x) == 1 && precedence(x) >=
precedence(item)) {
postfix_exp[j] = x; /* so pop all higher
precendence operator and */
j++;
x = pop(); /* add them to postfix expresion
*/
}
push(x);
/* because just above while loop will terminate
we have
oppped one extra item
for which condition fails and loop
terminates, so that one*/

push(item); /* push current oprerator symbol

onto stack */
}
else if (item == ')') /* if current symbol is ')'
then */
{
x = pop(); /* pop and keep popping until */
while (x != '(') /* '(' encounterd */
{
postfix_exp[j] = x;
j++;
x = pop();
}
}
else { /* if current symbol is neither operand not
'(' nor ')' and nor
operator */
printf("\nInvalid infix Expression.\n"); /* the
it is illegeal symbol */
getchar();
exit(1);
}
i++;
 item = infix_exp[i]; /* go to next symbol of infix
expression */
} /* while loop ends here */
if (top > 0) {
printf("\nInvalid infix Expression.\n"); /* the it
is illegeal symbol */
getchar();
exit(1);
}
if (top > 0) {
printf("\nInvalid infix Expression.\n"); /* the it
is illegeal symbol */
getchar();
exit(1);
}

postfix_exp[j] = '\0'; /* add sentinel else puts()

fucntion */
/* will print entire postfix[] array upto SIZE */
}

/* main function begins */

int main()
{
char infix[SIZE], postfix[SIZE]; /* declare infix string
and postfix string */

/* why we asked the user to enter infix expression

* in parentheses ( )
* What changes are required in porgram to
* get rid of this restriction since it is not
* in algorithm
* */
printf("ASSUMPTION: The infix expression contains single
letter variables and single digit constants only.\n");
printf("\nEnter Infix expression : ");
gets(infix);

InfixToPostfix(infix, postfix); /* call to convert */

printf("Postfix Expression: ");
puts(postfix); /* print postfix expression */

return 0;
}

Output:-
First Run:
Enter Infix expression : A+(B*C-(D/E^F)*G)*H
Postfix Expression: ABC*DEF^/G*-H*+

Second Run:
Enter Infix expression : (3^2*5)/(3*2-3)+5
Postfix Expression: 32^5*32*3-/5+