Data Structures & Algorithms
Today Topics
□
What are Stacks?
□
Representation of Stacks
□
Operations on Stacks
■
Push
■
Pop
■
IsEmpty
■
IsFull
□
Usage
□
Evaluation of Expressions
What are Stacks?
□
In array insertion and deletion can take place at
both end, i.e. start and end,
□
But if insertion and deletion are restricted from one
end, must used
STACKS and QUEUES.
Stack can be defined as:
□
A stack is a linear data structure which can
be accessed only at one of its ends for
storing and retrieving data
□
In which item may be inserted or deleted only from
one end called top of the stack.
□
There are two ways of implementing a stack:
■
Array (Static & Dynamic)
Example of Stack
□
A common model of a
stack is a plate or coin
stacker. Plates are
"pushed “onto to the top
and "popped" off from the
top.
□
Stacks principle
Last-In-First-Out (LIFO)
Stack terminology
“Top”: where insertion and
deletion take place
“Push”: is the term used to insert an
element into an stack
“Pop”: is the term used to delete an
element from a stack.
Basic operations of a Stack
New
Push
Pop
Peek
?
Implementation of Stacks
□
A stack can be implemented using an array
(static & dynamic)
□
A pointer variable
TOP
which contains the
location of the top element of the stack;
□
Variable
MAXSTK
which gives the maximum
number of elements that can be held by the
stack.
□
Note that all operations need check array
bounds
□
Pushing onto a full stack:
Overflow
■
When TOP=MAXSTK
□
Popping an empty stack:
Underflow
■
TOP=NULL
Operations on Stack
□
A stack is generally implemented with only
two principle operations:
■
Push: adds an item to a stack
■
Pop: extracts the most recently pushed item from
the stack
□
Other methods such as
■
top: returns the item at the top without removing
it
■
IsEmpty: determines whether the stack has
anything in it
■
IsFull: determines whether the stack is full or
stacksize is reached to MAXST anything in it
How the stack routines work
empty stack; push(a), push(b); pop
empty stack top = 0
a
push(a) top = 1b
a
push(b) top = 2a
pop() top = 1Algorithms of Push Operation
Push (STACK , TOP, MAXST, ITEM)
Algorithm for push element into the Stack
1.
[stack already filled]
If TOP= MAXSTK, then: print:
“OVERFLOW”,
and return.
2.
[increases TOP by 1] Set TOP:= TOP + 1
3.
[insert ITEM in new TOP position ]
Set STACK[TOP]: =ITEM
4. RETRUN
Algorithms of Pop Operation
Pop (STACK, TOP, ITEM)
Algorithm for pop element from the Stack
1.
[Stack has an item to be removed]
If TOP= NUL, then
Print:
“UNDERFLOW”
and return
2. [assign TOP element to ITEM]
Set ITEM := STACK[TOP]
3. [Decrease TOP by 1]
Set TOP:= TOP -1
4. Return
Algorithm for Display Stack
elements
Display_Stack ()
Algorithm for display stack elements
1.
Start
2.
Repeat step 3 For i = 1 to TOP by 1
3.
Print S[i]
Algorithm for isempty Stack
isempty ()
Algorithm for return the Stack status
1.
Start
2.
if TOP = -1 then
Return True
else
Return False
3.
End
Algorithm for return the top of
stack value
top ()
Algorithm for return the top of Stack
value
1.
Start
2.
Return TOP
Evaluation of Expression
□
Arithmetic expression is made up
■
Operands (Numeric Variables or
Constants)
■
Arithmetic Operators (+, -, *, /)
■
Power Operator (^)
■
Parentheses
□
The Expression is always evaluated
from left to right
Evaluation of Expression
□
Order in which the expression is evaluated is:
■
If the expression has parenthesis, then they are
evaluated first
■
Exponential (^) is given highest priority
■
Multiplication (*) and division (/) have the next
highest priority
■
Addition (+) and subtraction (-) have the lowest
priority
Evaluation of Expression
□
Steps to evaluate the following expression:
■
(2^3 + 6) * 2 – 9 / 3
■
= (8 + 6) * 2 – 9 / 3
■
= 14 * 2 – 9 / 3
■
= 28 – 3
Infix, Prefix (Polish) and Postfix
(Reverse Polish) Notation
Infix
Prefix
(Polish Notation)
Postfix
(Reverse Polish
Notation)
A+B
+AB
AB+
A*B
*AB
AB*
A/B
/AB
AB/
AB-Evaluation of Expression
□ Computer evaluates an expression given in infix notation by converting it into postfix notation.
□ Stack is used to perform this operation
□ Following steps are take to evaluate a postfix expression:
■ Expression is scanned from left to right until the end of the expression
■ When an operand is encountered, it is pushed into stack
■ When an operator is encountered, then
□ Top two operands of stack are removed
□ Arithmetic operation is performed
□ Computed result is pushed back to the stack
■ When end of the expression is reached, the top value from the stack is picked. It is the computed value of the expression
Infix to Postfix Conversion
□ Stack is used to convert an infix expression to postfix.
□ Stack is used to store operators and operands and then pass to the postfix expression according to their precedence.
□ Infix expression is converted into postfix expression according to the following rules:
■ Infix expression is scanned from left to right until end of the expression.
■ Operands are passed directly to the output.
■ Operators are first passed to the stacks.
Infix to Postfix Conversion
■ Each time an operator is read, the stack is repeatedly popped and operands are passed to the output, until an operator is reached that has a lower precedence than the most recently read operator. The most recently read
operator is then pushed onto the stack.
■ When end of the infix expression is reached, all operators remaining in the stack are popped and passed to the output in the same sequence.
■ Parentheses can be used in the infix expression but these are not used in the postfix expression.
■ During conversion process, parentheses are treated as operators that have higher precedence than any other operator.
Infix to Postfix Conversion
■
Left parenthesis is pushed into the stack, when
encountered.
■
Right parenthesis is never pushed to the stack.
■
Left parenthesis is popped only when right
parenthesis is encountered.
■
The parentheses are not passed to the output postfix
expressions. They are discarded.
■
When end of expression is reached, then all operators
from stack are popped and added to the output.
Example (Infix to Postfix
Conversion)
Convert infix expression
A+B*C+(D*E+F)*G into postfix A + B * C + ( D * E + F ) * G
1. Scanned from left to right. First operand read is A and passed to output
Stack Output: A
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
2. Next the ‘+’ operator is read, at this stage, stack is empty.
Therefore no operators are
popped and ‘+’ is pushed into the stack. Thus the stack and output will be:
+
Stack Output: A
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
3. Next the ‘B’ operand is read and passed to the output. Thus the stack and output will be:
+
Stack Output: AB
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
4. Next the ‘*’ operator is read, The stack has ‘+’ operator which has lower precedence than the ‘*’ operator. Therefore no operators are popped and ‘*’ is pushed into the stack. Thus the stack and
output will be:
* +
Stack Output: AB
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
5. Next the ‘C’ operand is read and passed to the output. Thus the stack and output will be:
* +
Stack Output: ABC
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
6. Next the ‘+’ operator is read, The stack has ‘*’ operator which has higher precedence than the ‘+’ operator. The Stack is popped and passed to output. Next stack has ‘+’ operator which has same precedence than the ‘+’ operator. The Stack is popped and passed to output. Now stack is empty, therefore no operators are
popped and ‘+’ is pushed into the stack. Thus the stack and output
will be: +
Stack Output: ABC*+
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
7. Next the left parenthesis ‘(’ is read, Since all operators have lower precedence than the left parenthesis, it is pushed into the stack. Thus the stack and output will be:
( +
Stack Output: ABC*+
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
8. Next the ‘D’ operand is read and passed to the output. Thus the stack and output will be:
( +
Stack Output: ABC*+D
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
9. Next the ‘*’ operator is read. Now, left parenthesis ‘(‘ has
higher precedence than ‘*’; it can not be popped from the stack
until a right parenthesis ‘)’ has been read. Thus the stack is not popped and ‘*’ is pushed into the stack. Thus the stack and output
will be: *
( +
Stack Output: ABC*+D
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
10. Next the ‘E’ operand is read and passed to the output. Thus the stack and output will be:
* ( +
Stack Output: ABC*+DE
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
11. Next the ‘+’ operator is read, The stack has ‘*’ operator which has higher precedence than the ‘+’ operator. The Stack is popped and passed to output. Next stack has left parenthesis ‘(’ which has not been popped and ‘+’ operator is pushed into the stack. Thus the
stack and output will be: + ( +
Stack Output: AB*+DE*
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
12. Next the ‘F’ operand is read and passed to the output. Thus the stack and output will be:
+ ( +
Stack Output: ABC*+DE*F
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
13. Next the ‘)’ has encountered now popped till ‘( ‘ and passed to the output. Thus the stack and
output will be:
+
Stack Output: ABC*+DE*F+
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
14. Next the ‘*’ operator is read, The stack has ‘+’ operator which has lower precedence than the ‘*’ operator. Therefore no operators are popped and ‘*’ is pushed into the stack. Thus the stack and
output will be:
* +
Stack Output: ABC*+DE*F+
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
15. Next the ‘G’ operand is read and passed to the output. Thus the stack and output will be:
* +
Stack
Example (Infix to Postfix
Conversion)
A + B * C + ( D * E + F ) * G
16. The end of expression is
encountered. The operators are popped from the stacked and
passed to the output in the same sequence in which these are
popped. Thus the stack and output will be:
Stack
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
1. Scanned from left to right. In first, second and third iteration, the value of A, B and C are pushed into the stack. Thus the stack will be:
9 6 5
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
2. In fourth iteration, the operator ‘*’ is read. So the two values ‘9’ and ‘6’ are popped from the stack and
multiplication is perform. i.e 9*6=54. The computed value pushed back to the stack. Thus the stack will be:
54 5
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
3. In fifth iteration, the operator ‘+’ is read. So the two values ‘54’ and ‘5’ are popped from the stack and
addition is perform. i.e 54+5=59. The computed value pushed back to the stack. Thus the stack will be:
59
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
4. In sixth and seventh iteration, the value of D and E are pushed into the stack. Thus the stack will be:
4 2 59
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
5. In eighth iteration, the operator ‘*’ is read. So the two values ‘4’ and ‘2’ are popped from the stack and
multiplication is perform. i.e 2*4=8. The computed value pushed back to the stack. Thus the stack will be:
8 59
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
6. In ninth iteration, the value of F is pushed into the stack. Thus the stack will be:
8 8 59
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
7. In tenth iteration, the operator ‘+’ is read. So the two values ‘8’ and ‘8’ are popped from the stack and
addition is perform. i.e 8+8=16. The computed value pushed back to the stack. Thus the stack will be:
16 59
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
8. In eleventh iteration, the value of G is pushed into the stack. Thus the stack will be:
3 16 59
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
9. In twelve iteration, the operator ‘*’ is read. So the two values ‘3’ and ‘16’ are popped from the stack and
multiplication is perform. i.e 3*16=48. The computed value
pushed back to the stack. Thus the
stack will be: 48
59
Example (Evaluation of Expression)
Postfix Expression
A B C * + D E * F + G * +
A=5, B=6, C=9, D=2, E=4, F=8, G=3
10. In thirteen iteration, the operator ‘+’ is read. So the two values ‘48’ and ‘59’ are popped from the stack and addition is perform. i.e 48+59=107. The computed value pushed back to the stack. Thus the stack will be:
107
