Data Structures (DS)

GTU # 3130702

Unit-2
Linear Data
Structure
(Stack)
Stack
 A linear list which allows insertion and deletion of an element at one end
only is called stack.
 The insertion operation is called as PUSH and deletion operation as POP.
 The most accessible elements in stack is known as top.
 The elements can only be removed in the opposite orders from that in
which they were added to the stack.
 Such a linear list is referred to as a LIFO (Last In First Out) list.
Deletio
n
Insertio
C n
B … …
A
TO
P
Stack Cont…
 A pointer TOP keeps track of the top element in the stack.
 Initially, when the stack is empty, TOP has a value of “zero”.
 Each time a new element is inserted in the stack, the pointer is
incremented by “one” before, the element is placed on the stack.
 The pointer is decremented by “one” each time a deletion is made
from the stack.
Applications of Stack
 Recursion
 Keeping track of function calls
 Evaluation of expressions
 Reversing characters
 Servicing hardware interrupts
 Solving combinatorial problems using backtracking
 Expression Conversion (Infix to Postfix, Infix to Prefix)
 Game Playing (Chess)
 Microsoft Word (Undo / Redo)
 Compiler – Parsing syntax & expression
 Finding paths
Procedure : PUSH (S, TOP, X)
 This procedure inserts an element X to the top of a stack.
 Stack is represented by a vector S containing N elements.
 A pointer TOP represents the top element in the stack.

1. [Check for stack overflow] Stack is empty, TOP TOP = -5

If TOP ≥ N = 0, N=3 3
TOP = 8
Then write (‘STACK PUSH(S, 2
TOP = 10
TOP, 10) 1
OVERFLOW’) S
Return PUSH(S,
TOP, 8)
2. [Increment TOP]
PUSH(S,
TOP ← TOP + 1 TOP, -5)
3. [Insert Element]
PUSH(S, TOP, 6)
S[TOP] ← X
4. [Finished] Overflow
Return
Function : POP (S, TOP)
 This function removes & returns the top element from a stack.
 Stack is represented by a vector S containing N elements.
 A pointer TOP represents the top element in the stack.

1. [Check for stack underflow] POP(S, TOP) TOP = -5

If TOP = 0 TOP =
3 8
TOP 2
= 10
Then write (‘STACK POP(S, TOP)
1
TOP = S
UNDERFLOW’) 0
Return (0) POP(S, TOP)
2. [Decrement TOP]
TOP ← TOP - 1 POP(S, TOP)
3. [Return former top element of
stack]
Underflow
Return(S[TOP + 1])
Function : PEEP (S, TOP, I)
 This function returns the value of the Ith element from the TOP of the
stack. The element is not deleted by this function.
 Stack is represented by a vector S containing N elements.
1. [Check for stack underflow] PEEP (S, TOP = -5
TOP, 2) 3 8
If TOP-I+1 ≤ 0
10
Then write (‘STACK PEEP (S,
TOP, 3) S
UNDERFLOW’)
Return (0) PEEP (S,
2. [Return Ith element from top TOP, 4)
of the stack] Underflo
Return(S[TOP–I+1]) w
PROCEDURE : CHANGE (S, TOP, X, I)
 This procedure changes the value of the Ith element from the top of the
stack to X.
 Stack is represented by a vector S containing N elements. -5
1. [Check for stack underflow] CHANGE (S, TOP, TOP =
50, 2) 3 8
50
If TOP-I+1 ≤ 0
9
10
Then write (‘STACK
CHANGE (S, TOP, S
UNDERFLOW’) 9, 3)
Return
2. [Change Ith element from top CHANGE (S, TOP,
of the stack] 25, 8)
S[TOP–I+1] ← X
Underflow
3. [Finished]
Return
Algorithm: RECOGNIZE
Write an algorithm which will check that the given string belongs to
following grammar or not.
L= {wcwR | w Є {a,b}*} (Where wR is the reverse of w)

Example of valid abcb aabbcb

strings
Example :of Invalid a
aabca baa
strings: ab
• Given an input string named STRING on the alphabet {a, b, c} which contains
a blank in its rightmost character position.
• Function NEXTCHAR returns the next symbol in STRING.
• This algorithm determines whether the contents of STRING belong to the above
language.
• The vector S represents the stack and TOP is a pointer to the top element of the
stack.
Algorithm: RECOGNIZE
1. [Initialize stack by placing a 3. [Scan characters following ‘c’;
letter ‘c’ on the top] Compare them to the characters
TOP  1 on stack]
S [TOP] ← ‘c’ Repeat While S [TOP] ≠ ‘c’
NEXT ← NEXTCHAR (STRING)
2. [Get and PUSH symbols until
X ← POP (S, TOP)
either ‘c’ or blank is
If NEXT ≠ X
encountered]
Then Write(‘INVALID STRING’)
NEXT ← NEXTCHAR (STRING)
Exit
Repeat while NEXT ≠ ‘c’
If NEXT = ‘ ‘ 4. [Next symbol must be blank]
Then Write (‘Invalid NEXT ← NEXTCHAR (STRING)
String’) If NEXT = ‘ ‘
Exit Then Write (‘VALID STRING’)
Else Call PUSH (S, TOP, Else Write (‘INVALID STRING’)
NEXT) 5. [Finished]
NEXT ← NEXTCHAR Exit
(STRING)
Algorithm: RECOGNIZE
1. [Initialize stack by placing Input String: a b
a letter ‘c’ on the top] cba□
TOP  1 NEXT
S [TOP] ← ‘c’ Charac Stack
2. [Get and PUSH symbols until ter Conten
Scann t
either c’ or blank is 1 c
ed
encountered]
a ca
NEXT ← NEXTCHAR (STRING)
Repeat while NEXT ≠ ‘c’ 2 b cab
If NEXT = ‘ ‘ c cab
Then Write (‘Invalid
String’)
Exit
Else Call PUSH (S, TOP,
NEXT)
NEXT ← NEXTCHAR
(STRING)
Algorithm: RECOGNIZE
Input String: a b
3. Scan characters following ‘c’; cba□
Compare them to the characters on NEXT
stack
Repeat While S[TOP] ≠ ‘c’ Charac Stack
NEXT ← NEXTCHAR (STRING) ter Conten
X ← POP (S, TOP) Scann t
1 c
ed
If NEXT ≠ X
a ca
Then Write(‘Invalid String’)
Exit 2 b cab
4. [Next symbol must be blank] c cab
NEXT ← NEXTCHAR (STRING)
If NEXT = ‘ ‘ b ca
3
Then Write (‘VALID STRING’) a c
Else Write (‘INVALID STRING’) □
Algorithm : RECOGNIZE
 Write an algorithm to determine if an input character string is of the form
aibi where i>=1
 i.e. number of a should be equal to no of b
Polish Expression & their Compilation
 Evaluating Infix Expression

a+b*c+d*e
1 2
3
4

 A repeated scanning from left to right is needed as operators

appears inside the operands.
 Repeated scanning is avoided if the infix expression is first
converted to an equivalent parenthesis free prefix or suffix (postfix)
expression.
 Prefix Expression: Operator, Operand, Operand
Polish Notation
 This type of notation is known Lukasiewicz Notation or Polish
Notation or Reverse Polish Notation due to Polish logician Jan
Lukasiewicz.
 In both prefix and postfix equivalents of an infix expression, the
variables are in same relative position.
 The expressions in postfix or prefix form are parenthesis free and
operators are rearranged according to rules of precedence for operators.
Polish Notation
Sr. Infix Postfix Prefix
1 a a a
2 a +b ab+ +ab
3 a +b+c ab+c+ ++abc
4 a + (b + c) abc++ +a+bc
5 a + (b * c) abc*+ +a * b c
6 a * (b + c) abc+* *a+bc
7 a *b*c a b *c* ** a b c

a+b+c a+b+c (ab+)+ c (ab+) c + ab+c+

Finding Rank of any Expression
E = ( A + B * C / D - E + F / G / ( H + I ))
Note: R = Rank, Rank of Variable = 1, Rank of binary operators = -
1
Rank (E) = R(A) + R(+) + R(B) + R(*) + R(C) + R (/) + R(D) + R(-) + R(E)
+ R(+) + R(F) + R(/) + R(G) + R(/) + R(H) + R(+)
+ R(I)
Rank (E) = 1 + (-1) + 1 + (-1) + 1 + (-1) + 1 + (-1) + 1 + (-1) + 1 + (-
1) + 1 + (-1) + 1 + (-1) + 1
Rank (E) = 1

Any Expression is valid if Rank of that

expression is 1
Convert Infix to Postfix Expression
Symbol Input Stack Rank function
precedence precedence (R)
function (F) function (G)
+, - 1 2 -1
*, / 3 4 -1
^ 6 5 -1
Variables 7 8 1
( 9 0 -
) 0 - -
Algorithm : REVPOL
 Given an input string INFIX containing an infix expression which has been
padded on the right with ‘)’.
 This algorithm converts INFIX into reverse polish and places the result
in the string POLISH.
 All symbols have precedence value given by the table.
 Stack is represented by a vector S, TOP denotes the top of the stack,
algorithm PUSH and POP are used for stack manipulation.
 Function NEXTCHAR returns the next symbol in given input string.
 The integer variable RANK contains the rank of expression.
 The string variable TEMP is used for temporary storage purpose.
1. [Initialize Stack] 5. [Remove symbols with greater
TOP  1 precedence from stack]
S[TOP] ← ‘(’ IF TOP < 1
Then write (‘INVALID’)
2. [Initialize output string and rank
EXIT
count]
Repeat while G(S[TOP]) > F(NEXT)
POLISH  ‘’
TEMP  POP (S, TOP)
RANK  0
3. [Get first input symbol] POLISH  POLISH O TEMP
NEXT  NEXTCHAR(INFIX) RANK  RANK + R(TEMP)
4. [Translate the infix expression] IF RANK <1
Repeat thru step 7 Then write (‘INVALID’)
while NEXT != ‘ ‘ EXIT
6. [Are there matching parentheses]
Symbol IPF (F) SPF (G) RF (R) IF G(S[TOP]) != F(NEXT)
+, - 1 2 -1 Then call PUSH (S,TOP, NEXT)
Else POP (S,TOP)
*, / 3 4 -1
7. [Get next symbol]
^ 6 5 -1 NEXT  NEXTCHAR(INFIX)
Variables 7 8 1 8. [Is the expression valid]
IF TOP != 0 OR RANK != 1
( 9 0 -
Then write (‘INVALID‘)
) 0 - - Else write (‘VALID’)
 (a+b^c^d)*(e+f/ Input Content Reverse polish Rank
d)) Symb of stack expression
ol ( 0
NEXT (

1. [Initialize Stack]
TOP  1
S[TOP] ← ‘(’
2. [Initialize output string and rank
count]
POLISH  ‘’
RANK  0
3. [Get first input symbol]
NEXT  NEXTCHAR(INFIX)
 Input Content of Reverse Rank
(a+b^c^d)*(e+f/d)) Symbol stack polish
( expression 0
NEXT ( 0
((
4. [Translate the infix expression]
Repeat thru step 7 a ((a 0
while NEXT!= ‘ ‘ + ((+
(( a 1
5. [Remove symbols with greater precedence from b ((+b a 1
stack] ((+
((+^ ab 2
^
IF TOP < 1
c ((+^ ab 2
Then write (‘INVALID’)
EXIT ^ c
((+^ abc 3
Repeat while G(S[TOP]) > F(NEXT) d ^
((+^ abc 3
TEMP  POP (S, TOP)
POLISH  POLISH O TEMP ) ^d
((( abcd^^ 1
RANK  RANK + R(TEMP) +
IF RANK <1
Then write (‘INVALID’)
EXIT

6. [Are there matching parentheses]

IF G(S[TOP]) != F(NEXT)
Then call PUSH (S,TOP, NEXT)
Else POP (S,TOP)
7. [Get next symbol]
NEXT  NEXTCHAR(INFIX)
Perform following operations
 Convert the following infix expression to postfix. Show the stack
contents.
 A$B-C*D+E$F/G
 A+B–C*D*E$F$G
 a+b*c-d/e*h
 ((a+b^c^d)*(e+f/d))

 Convert the following infix expression to prefix.

 A+B–C*D*E$F$G
General Infix-to-Postfix Conversion
Create an empty stack called stack for keeping operators. Create an
empty list for output.
Read the character list from left to right and perform following steps
1 If the character is an operand (Variable), append it to the end of the output list
2 If the character is a left parenthesis ‘(’, push it on the stack
3 If the character is a right parenthesis ‘)’, pop the stack until the corresponding
left parenthesis ‘)’ is removed. Append each operator to the end of the
output list.
4 If the token is an operator, *, /, +, or -, push it on the stack. However, first
remove any operators already on the stack that have higher or equal
precedence and append them to the output list.
(a+b^c^d)*(e+f/d)
Evaluation of postfix expression
 Each operator in postfix string refers to the previous two operands in
the string.
 Each time we read an operand, we PUSH it onto Stack.
 When we reach an operator, its operands will be top two elements on
the stack.
 We can then POP these two elements, perform the indicated operation on
them and PUSH the result on the stack so that it will available for use as
an operand for the next operator.
Evaluation of postfix expression
Evaluate Expression: 5 6 2 - +

Empty
Read – , is it
Stack Read 5, is it operator? POP two
operand? PUSH
Read 6, is it 2 symbols and
perform operation
operand? PUSH
Read 2, is it 6 and PUSH result 4
operand? PUSH 5 Operan – Operan 5
d1 d2
Read + , is it
Read next operator? POP two
symbol, if it is symbols and perform
end of string, operation and PUSH
POP answer result
Answ 9
er
from Stack Operan
d1
+ Operan
d2
Algorithm: EVALUATE_POSTFIX
 Given an input string POSTFIX representing postfix expression.
 This algorithm evaluates postfix expression and put the result into
variable VALUE.
 Stack is represented by a vector S, TOP denotes the top of the stack,
Algorithm PUSH and POP are used for stack manipulation.
 Function NEXTCHAR returns the next symbol in given input string.
 OPERAND1, OPERAND2 and TEMP are used for temporary variables
 PERFORM_OPERATION is a function which performs required operation
on OPERAND1 & OPERAND2.
Algorithm: EVALUATE_POSTFIX
1. [Initialize Stack]
TOP  0
VALUE  0
2. [Evaluate the postfix expression]
Repeat until last character
TEMP  NEXTCHAR (POSTFIX)
If TEMP is DIGIT
Then PUSH (S, TOP, TEMP)
Else OPERAND2  POP (S, TOP)
OPERAND1  POP (S, TOP)
VALUE  PERFORM_OPERATION(OPERAND1, OPERAND2, TEMP)
PUSH (S, POP, VALUE)
3. [Return answer from stack]
Return (POP (S, TOP))
Evaluation of postfix expression
Evaluate Expression: 5 4 6 + * 4 9 3 / + *
Evaluate Expression: 7 5 2 + * 4 1 1 + / -
Evaluate Expression: 12, 7, 3, -, /, 2, 1, 5, +, *, +
Algorithm: EVALUATE_PREFIX
 Given an input string PREFIX representing prefix expression.
 This algorithm evaluates prefix expression and put the result into variable
VALUE.
 Stack is represented by a vector S, TOP denotes the top of the stack,
Algorithm PUSH and POP are used for stack manipulation.
 Function NEXTCHAR returns the next symbol in given input string.
 OPERAND1, OPERAND2 and TEMP are used for temporary variables
 PERFORM_OPERATION is a function which performs required operation
on OPERAND1 & OPERAND2.
Algorithm: EVALUATE_PREFIX
1. [Initialize Stack]
TOP  0
VALUE  0
2. [Evaluate the prefix expression]
Repeat from last character up to first
TEMP  NEXTCHAR (PREFIX)
If TEMP is DIGIT
Then PUSH (S, TOP, TEMP)
Else OPERAND1  POP (S, TOP)
OPERAND2  POP (S, TOP)
VALUE  PERFORM_OPERATION(OPERAND1, OPERAND2, TEMP)
PUSH (S, POP, VALUE)
3. [Return answer from stack]
Return (POP (S, TOP))
Recursion
A procedure that contains a procedure call to itself or a procedure
call to second procedure which eventually causes the first
procedure to be called is known as recursive procedure.
Two important conditions for any recursive procedure
1 Each time a procedure calls itself it must be nearer in some sense to a solution.
2 There must be a decision criterion for stopping the process or computation.

Two types of recursion

Primitive Non-Primitive
Recursion Recursion
This is recursive defined function. This is recursive use of procedure.
E.g. Factorial function E.g. Find GCD of given two numbers
Algorithm to find factorial using recursion
 Given integer number N
 This algorithm computes factorial of N.
 Stack S is used to store an activation record associated with each
recursive call.
 TOP is a pointer to the top element of stack S.
 Each activation record contains the current value of N and the current
return address RET_ADDE.
 TEMP_REC is also a record which contains two variables PARAM &
ADDRESS.
 Initially return address is set to the main calling address. PARAM is set
to initial value N.
Algorithm: FACTORIAL
1. [Save N and return Address]
CALL PUSH (S, TOP, TEMP_REC)
2. [Is the base criterion found?]
If N=0
then FACTORIAL  1
GO TO Step 4
Else PARAM  N-1
ADDRESS  Step 3
GO TO Step 1
3. [Calculate N!]
FACTORIAL N * FACTORIAL
4. [Restore previous N and return address]
TEMP_REC  POP(S,TOP)
(i.e. PARAM  N, ADDRESS  RET_ADDR)
GO TO ADDRESS
Trace of Algorithm FACTORIAL, N=2
Level Description Stack
Number
Enter Step 1: PUSH (S,0,(N=2, main 2 Content
Level 1 address))
Step 2: N!=0 Main
(main PARAM  N-1 (1), ADDR  Addres
call) Step 3 s
TOP

Enter Level 2 Step 1: PUSH (S,1,(N=1, step 2 1

(first 3)) 2: N!=0
Step Main Step
recursive PARAM  N-1 (3), ADDR  Addres 3
call) Step 3 s TOP
Enter Level 3 Step 1: PUSH (S,2,(N=0, step 2 1 0
(second 3)) 2: N=0
Step Main Step Step
recursive FACTORIAL  1 Addres 3 3
call) s TOP
Step 4: POP(A,3)
GO TO Step 3 2 1
Main Step
Addres 3
s TOP
Trace of Algorithm FACTORIAL, N=2
Level Description Stack
Number Content
Step 3: FACTORIAL  1*1 2
Return to Main
Level 2 Step 4: POP (A,2) Addres
GO TO Step 3 s
TOP

Return to Step 3: FACTORIAL  2*1

Level 1
Step 4: POP (A,1)
GO TO Main Address
TOP = 0
Data Structures (DS)
GTU # 3130702

Thank
You