UNIT:

3
Stack & Queue
1
 SYLLABUS

1. Linear and Non-Linear Data Structures

2. Stack : Array representation of Stack, PUSH POP
Operations on Stack, Implementation of Stack, Application of
Stack, Infix, Prefix and Postfix Forms of Expressions,
Recursive Functions (factorial, greatest common divisor,
Fibonacci series)
3. Queue: Array representation of Queue, Operations on
Queue, Implementation of Queue, Limitation of Single Queue
4. Concepts of Circular Queue
5. Application of queue
6. Difference circular queue and simple queue

2
3.1 LINEAR AND NON-LINEAR DATA
STRUCTURES
 Linear Data Structure:
 In the linear data structure processing of data items is
possible in linear fashion.
 Data are processed one by one sequentially.

 Examples of the linear data structure are:

 (A) Array (B) Stack (C) Queue (D) Linked List

 Non Linear data structure:

 In the Non linier data structure processing of data items is
not
possible in linier fashion.
 Examples of the non linier data structure are:
3
 (A)Tree (B) Graph
 3.2 STACK
 A stack is a linear OR non-primitive list in which insertion
and deletion operations are performed at only one end of the
list.
 A stack is Last in First out (LIFO) Structure.

 A stack is a linear data structure in which elements are

added and remove from one end, called top of stack.
 For example of stack is, consider a stack of plates on the
counter in cafeteria, during the time of dinner, customer take
plates from top of the stack and waiter puts the washed
plates on the top of the stack. So new plates are put on the top
and old one yet bottom.
 Another example is Railway Shunting System.
4
 ARRAY REPRESENTATION OF
STACK Representation of stack
1.Verticaly

5
 The operation in a stack is representation by using
vector consisting of number of elements.
 A pointer top keeps of the top elements ,when stack is
empty to phas a value 0.
 Every time a new element is added at top,top is incremented
by one.
 When an element is deleted from a top,top is decremented
by one.
2.Horizontal Representation of stack

6
IMPLEMENTATION OF STACK
 Implementation of Stack:
 A stack is a list and list can be implemented
by two ways:
1. Pointer(linked List/ Dynamic Implementation)
2. Array(Static Implementation)

7
OPERATIONS ON STACK
1. Push Operation:
 The operations that add an element to the top
of the stack is called PUSH operation. It is
used to insert an element into the stack.
2. Pop Operation:
 The operation that delete top element
from the top of stack is called POP. it is
used to delete an element from stack

8
PUSH POP OPERATIONS ON
STACK
1. PUSH Operation
 In push operation, we can add elements to the top of the
stack, so before push operation, user must check the stack, it
should not be a full.
 If stack is already full and when we try to add the elements
then error occurs. It is called “Stack Over Flow” error.

 Algorithm: PUSH(S, TOP, VAL)

 This algorithm insert an element X to the top of the stack.

 The Stack is represented by vector S which contains N

elements.
 TOP is a pointer which points to the top element of the Stack.
Step-1: [Check for stack overflow]
If (TOP >= N) then
Write (‘Stack Overflow’)
Return
Step-2: [Increment TOP]
TOP = TOP + 1
Step-3: [Insert Element]
S [TOP] = VAL
Step-4: [Finished]
Return

10
2. POP Operation
 In POP operation, we can delete or remove an elements from
top of the stack, so before pop operation, user must check
the stack, stack should not be a empty.

 If the stack is empty, and we try to pop an element, then
error
occur. It is called “Stack under Flow” error.

 Algorithm: POP(S, TOP)

 This algorithm removes an element from the Top of the
Stack.
 The Stack is represented by vector S which contains N
elements.
 TOP is a pointer which points to the top element of the
Step-1: [Check for the Underflow on the Stack]
If TOP = 0 then
Write (‘STACK UNDERFLOW’)
Exit
Step-2:[Decrement Pointer]
TOP = TOP - 1
STEP-3:[Return former top element of the
stack]
Return(S [TOP + 1])

12
 INFIX, PREFIX AND POSTFIX FORMS OF
EXPRESSIONS
 There are basically three types of polish notation:
 Infix (B) Prefix (C) Postfix

 When the operator(+) exists between two operands(A & B)

then it is known as Infix notation.(e.g. A+B)
 When the operator(+) are written before their operands(A & B)
then it is known as Prefix notation(Polish notation). (e.g. +AB)
 When the operator(+) are written after their operands(A & B)
then it is known as Postfix notation(Reverse polish
notation). (e.g. AB+).
 Stack is widely used to convert infix notation into prefix
or postfix notation. 13
Rules for converting infix notation to prefix/ postfix
 The operations with heights precedence are converted first
and then after a portion of the expression have been converted
to postfix.
 It is to be treated as single operand.

 Take only two operands at a time to convert in a postfix

from like A+B AB+
 Always, convert the parenthesis first

 Convert postfix exponentiation second if there are more

than one exponentiation in sequence then take order from
right to left.
 Convert in to postfix as multiplication and division
operator, left to right.
 Convert in postfix as addition and subtraction left to 14

right.
 Convert infix into Prefix expression.

1. (A + B) * C 2. (A + B ) * (C + D) 3. (A-B)+C*A+B
= (+ A B) * C = (+ A B) * (+ C D) =-AB+C*A+B
= * (+ A B) C =*(+ A B) (+ C D) =-AB+*CA+B
=*+ABC =* + AB + CD =+-AB*CA+B
=++-AB*CAB

4. (B*C/D)/(D/C+E) 5. A*B/(C+D-E)
=(*BC/D)/(D/C+E) =A*B/(+CD-E)
=(/*BCD)/(D/C+E) =A*B/(-+CDE)
=(/*BCD)/(/DC+E) =*AB/-+CDE
=(/*BCD)/(+/DCE) =/*AB-+CDE
=//*BCD+/DCE 15
 Convert infix into Prefix expression.

1. A * B / C +D 2. C*B*A/D 3. (A-B)+C*A+B
= [AB*]/C+D = [CB*]*A/D = [AB-] +C*A+B
= [AB*C/] +D = [CB*A*]/D = [AB-] + [CA*] +B
=AB*C/D+ =CB*A*D/ = [AB-CA*+] +B
=AB-CA*+B+

4. A*B/(C+D-E) 5. (B*C/D)/(D/C+E) 6. A*B+C*D+E*F

=A*B/([CD+]-E)
= ([BC*]/D)/(DC/+E) =[AB*]+C*D+E*F
=A*B/[CD+E-]
=[AB*]+[CD*]+E*F
=[AB*]/[CD+E-] = [BC*D/]/[DC/E+] =[AB*]+[CD*]+[EF*]
=AB*CD+E-/ =[AB*CD*+]+[EF*]
=BC*D/DC/E+/
=AB*CD*+EF*+

16
APPLICATION OF
STACK
 There are three main application of stack:

(1) Recursion:
 Recursion means function call itself.

 It is the technique of defining a process in terms of itself.

 Stack is widely used in recursion because of its Last in First

out Property.
 In terms of C language the function calling itself is known
as recursion.
(2)Evaluate polish notation:
 The process of writing the operators of an expression
either before their operands or after operands are
17
called the polish notatio.
 There are basically three types of polish notation:
 Infix (B) Prefix (C) Postfix

(3) Stack Machine:

 Stack Machines are also used to evaluate polish notations.

 Two example of the stack machine are PDP-11 and B5000.

These machines are well suited for stacking local variables
and parameter that arise in the function call.
 Stack machines provides faster execution of polish
notation.

18
RECURSIVE FUNCTIONS (FACTORIAL,
GREATEST COMMON DIVISOR,
FIBONACCI SERIES)
 Recursion means a function call itself.
 Example: The factorial function can be recursively defined
as,

 Here, FACTORIAL(N) is defined in terms of FACTORIAL(N-1)

which is again defined in terms of FACTORIAL(N-2) and this
process continue until FACTORIAL(0) is reached.
19
 The value of FACTORIAL(0) is defined as 1.
 ToGenerate the Fibonacci number using
recursion:
A fibonacci series is,
0 1 1 2 3 5 8 ………………. N
 If we consider F0 = 0 and F1 = 1 then F2 = F0 + F1 = 0 + 1
= 1, similar F3 = F2 + F1 = 1 + 1 = 2, and F4 = F3 + F2 =
2
+ 1 = 3 and so on.
 It is clear that each succeeding(next) term is the sum of
two preceding(previous) terms, doing this procedure until
i
becomes less then the value of n.

20
 Greatest Common Divisor (GCD):
 To implement Greatest Common Divisor(GCD) function
in a recursive form using following steps:
 If m <= n and n % m = 0 then gcd(n, m) =
m(Termination
step).
 If n < m then gcd(n, m) = gcd(m, n) ( Recursive
definition of
gcd)
 If n >= m then gcd(n, m) = gcd(m, n % m) (Recursive
definition of gcd)

21
3.3 QUEUE
 A queue is a linear list in which insertion is performed at one
end called rear end and deletion is performed at another end
of the list called front end.
 The information in such a list is proceeds in the same order as
it was received.
 Since insertion is performed at one end and deletion is
performed at another end the element which is inserted first is
first to delete. So it is also known as First in First out
(FIFO) or First Come First Serve (FCFS) data structure.

22
ARRAY REPRESENTATION OF
QUEUE
A queue has two pointer, from pointer and rear
pointer which are pointing to front and rear element
of the queue.

23
IMPLEMENTATION OF QUEUE
A Queue is a list and list can be
implemented by two ways:
1. Pointer(linked List/ Dynamic Implementation)
2. Array(Static Implementation)

24
OPERATIONS ON
QUEUE
1. QINSERT (Q, Front, Rear, N, Val)
 This function insert an element into the queue

 The Queue is represented by vector Q which contains

N elements.
 Front is a pointer which points to the front end

 Rear is a pointer which points to the rear end

 Y is the element to be inserted.

 ALGORITHM:QINSERT

STEP-1: [Check Overflow error?]

 If Rear≥N then
 Write (‘Queue Overflow’)
25
 Exit
Step-2: [Increment rear pointer]
RearRear+1
Step-3: [Insert element]
Q[Rear] Val
Step-4:[Is front pointer properly set?]
If Front=0 then
Front1
Return
Step-5: [Finished]
Exit

26
2. Algorithm to delete an element from the queue
 QDELETE (Q, Front, Rear)
 The Queue is represented by vector Q which contains
N elements.
 Front is a pointer which points to the front end

 Rear is a pointer which points to the rear end

Step-1: [Underflow?]
If Front = 0 then
Write (‘Queue Underflow’)
Exit
Step-2:[Delete element]
XQ [F]
27
Step-3:[Queue empty?]
If Front =Rear
Then FrontRear0
Else FrontFront+1
Step-4:[Return element]
Return (X)

28
LIMITATION OF SINGLE QUEUE
 Disadvantage of simple queue is that even if we have a free
memory space in a queue we cannot use that free memory
space to insert element.
 For example consider following operations:

 As shown in figure we insert three elements 5, 10, 15 in

simple queue. After that we delete 5 and 10 as shown in
figure. Now even we have a free memory space we cannot use
that memory space. So simple queue results in wastage of
memory space. This problem can be solved by using circular
queue.
 For example consider the following operations: 29
 As shown in 1st figure, we insert eight elements 10,
20,30,40,50,60,70,80 in simple queue. After that we delete
10, 20 and 30 as shown in 2nd figure. Now we have a free
memory space in circular queue and we can use that
memory space by incrementing rear pointer by 1(rear=0).

30
3.4 CONCEPTS OF CIRCULAR
QUEUE
 A circular queue is a queue in which elements are
arranged such that the first element in the queue
follows the last element in the queue.
 The arrangement of circular queue is shown in
figure below:

31
 Here in the circular queue the first element
q[0] follows the last element q[n-1].
 Disadvantage of simple queue is that even if
we have a free memory space in a queue we
cannot use that free memory space to insert
element.

32
 3.5 APPLICATION OF QUEUE
 A queue is the natural data structure for a system to serve its
incoming requests. Most of the process scheduling or disk
scheduling algorithms in operating systems use queues.
 Computer hardware like a processor or a network card also maintain
buffers in the form of queues for incoming resource requests. A
stack-like data structure causes starvation of the first requests, and is
not applicable in such cases.
 A mailbox or port to save messages to communicate between two
users or processes in a system is essentially a queue-like structure.
 Queue is widely used in Simulation.

33
3.6 DIFFERENCE OF CIRCULAR
QUEUE AND SIMPLE QUEUE
Simple Queue Circular Queue
The last element of the queue The last element in the queue
does not follow the first element. follow the first element.
Problem of Overflow in a simple Problem of Overflow in a circular
queue is frequently occurs. queue infrequently occurs.

There is wastage of Memory There is no wastage of Memory

space. space.
Example of Simple queue Example of Circular queue

34