stack & queue

STACKS &
QUEUES
Presented by :-
MANJU RANI

DATA
STRUCTURE
LINEAR DATA
STRUCTURE
ARRAY QUEUE STACK
NON LINEAR
DATA
STRUCTURE

What is Linear Data Structure
In linear data structure, data is arranged
in linear sequence.
 Data items can be traversed in a single
run.
 In linear data structure elements are
accessed or placed in contiguous(together
in sequence) memory location.

WHAT Is
 A stack is called a last-in-first-out (LIFO)
collection. This means that the last thing
we added (pushed) is the first thing that
gets pulled (popped) off.
 A stack is a sequence of items that are
accessible at only one end of the sequence.

Operations that can be performed
on STACK:
 PUSH.
 POP.

PUSH : It is used to insert items into the stack.
POP: It is used to delete items from stack.
TOP: It represents the current location of data
in stack.

ALGORITHM OF INSERTION IN
STACK: (PUSH)
1. Insertion(a,top,item,max)
2. If top=max then
print ‘STACK OVERFLOW’
exit
else
3. top=top+1
end if
4. a[top]=item
5. Exit

ALGORITHM OF DELETION IN
STACK: (POP)
1. Deletion(a,top,item)
2. If top=0 then
print ‘STACK UNDERFLOW’
exit
else
3. item=a[top]
end if
4. top=top-1
5. Exit

ALGORITHM OF DISPLAY IN
STACK:
1.Display(top,i,a[i])
2.If top=0 then
Print ‘STACK EMPTY’
Exit
Else
3.For i=top to 0
Print a[i]
End for
4.exit

APPLICATIONS OF STACKS ARE:
I. Reversing Strings:
• A simple application of stack is reversing strings.
To reverse a string , the characters of string are
pushed onto the stack one by one as the string
is read from left to right.
• Once all the characters
of string are pushed onto stack, they are
popped one by one. Since the character last
pushed in comes out first, subsequent pop
operation results in the reversal of the string.

For example:
To reverse the string ‘REVERSE’ the string is
read from left to right and its characters are
pushed . LIKE:
onto a stack.

II. Checking the validity of an expression
containing nested parenthesis:
• Stacks are also used to check whether a given
arithmetic expressions containing nested
parenthesis is properly parenthesized.
• The program for checking the validity of an
expression verifies that for each left parenthesis
braces or bracket ,there is a corresponding
closing symbol and symbols are appropriately
nested.

For example:
VALID INPUTS INVALID INPUTS
{ }
( { [ ] } )
{ [ ] ( ) }
[ { ( { } [ ] ( {
})}]
{ ( }
( [ ( ( ) ] )
{ } [ ] )
[ { ) } ( ] } ]

III. Evaluating arithmetic expressions:
INFIX notation:
The general way of writing arithmetic
expressions is known as infix notation.
e.g, (a+b)
PREFIX notation:
e.g, +AB
POSTFIX notation:
e.g: AB+

Conversion of INFIX to POSTFIX conversion:
Example: 2+(4-1)*3 step1
2+41-*3 step2
2+41-3* step3
241-3*+ step4

CURRENT
SYMBOL
ACTION
PERFORMED
STACK STATUS POSTFIX
EXPRESSION
( PUSH C C 2
2 2
+ PUSH + (+ 2
( PUSH ( (+( 24
4 24
- PUSH - (+(- 241
1 POP 241-
) (+ 241-
* PUSH * (+* 241-
3 241-3
POP * 241-3*
POP + 241-3*+
)
CONVERSION OF INFIX INTO POSTFIX
2+(4-1)*3 into 241-3*+

 Queue is an ADT data structure similar to stack,
except that the first item to be inserted is the first
one to be removed.
 This mechanism is called First-In-First-Out (FIFO).
 Placing an item in a queue is called “insertion or
enqueue”, which is done at the end of the queue
called “rear”.
 Removing an item from a queue is called “deletion
or dequeue”, which is done at the other end of the
queue called “front”.
 Some of the applications are : printer queue,
keystroke queue, etc.

1.To insert an element in
queue
2.Delete an element from
queue

Placing an item in a queue is called
“insertion or enqueue”, which is done
at the end of the queue called “rear”.
Front
Rear

Removing an item from a queue is
called “deletion or dequeue”, which
is done at the other end of the
queue called “front”.
Front
Rear

1.If (rear = maxsize-1 )
print (“queue overflow”) and return
2.Else
rear = rear + 1
Queue [rear] = item

1.If (front =rear)
print “queue empty” and return
2. Else
Front = front + 1
item = queue [front];
Return item

 Real life examples
Waiting in line
Waiting on hold for tech support
 Applications related to Computer Science
Round robin scheduling
Job scheduling (FIFO Scheduling)
Key board buffer

1.Queue is empty
FRONT=REAR
2.Queue is full
REAR=N
3.Queue contains element >=1
FRONT<REAR
NO. OF ELEMENT=REAR-FRONT+1

1.Using an array
2.Using linked list

 To solve this problem, queues implement
wrapping around. Such queues are called
Circular Queues.
 Both the front and the rear pointers wrap
around to the beginning of the array.
 It is also called as “Ring buffer”.
 Items can inserted and deleted from a
queue in O(1) time.

+Queue()
+insert() : void
+remove() : long
+peekFront() : long
+isEmpty() : bool
+isFull() : bool
+size() : int
-maxSize : int
-queueArray [] : long
-front : int
-rear : int
-nItems : int
Queue
QueueApp
Interface1

 C:Documents and SettingsboxMy
DocumentsCSCSC220ReaderProgramsRe
aderFilesChap04Queuequeue.java

 Normal queue (FIFO)
 Circular Queue (Normal Queue)
 Double-ended Queue (Deque)
 Priority Queue

 It is a double-ended queue.
 Items can be inserted and deleted from
either ends.
 More versatile data structure than stack or
queue.
 E.g. policy-based application (e.g. low
priority go to the end, high go to the front)
 In a case where you want to sort the queue
once in a while, What sorting algorithm will
you use?

 More specialized data structure.
 Similar to Queue, having front and rear.
 Items are removed from the front.
 Items are ordered by key value so that the
item with the lowest key (or highest) is
always at the front.
 Items are inserted in proper position to
maintain the order.
 Let’s discuss complexity

+Queue()
+insert() : void
+remove() : long
+peekMin() : long
+isEmpty() : bool
+isFull() : bool
-maxSize : int
-queueArray [] : long
-nItems : int
PrioityQ
PriorityQApp
Interface1

 Used in multitasking operating system.
 They are generally represented using “heap”
data structure.
 Insertion runs in O(n) time, deletion in O(1)
time.
DocumentsCSCSC220ReaderProgramsRe
aderFilesChap04PriorityQpriorityQ.java

 2 + 3
 2 + 4 * 5
 ((2 + 4) * 7) + 3* (9 – 5))
 Infix vs postfix
 Why do we want to do this
transformation?
• 2 3 +
• 2 4 5 * +
• 2 4 + 7 * 3 9 5 - * +

 Read ch from input until empty
◦ If ch is arg , output = output + arg
◦ If ch is “(“, push ‘(‘;
◦ If ch is op and higher than top push ch
◦ If ch is “)” or end of input,
 output = output + pop() until empty or top is “(“
◦ Read next input
DocumentsCSCSC220ReaderPrograms
ReaderFilesChap04Postfixpostfix.java

 5 + 2 * 3 -> 5 2 3 * +
 Algorithm
◦ While input is not empty
◦ If ch is number , push (ch)
◦ Else
 Pop (a)
 Pop(b)
 Eval (ch, a, b)
DocumentsCSCSC220ReaderProgramsR
eaderFilesChap04Postfixpostfix.java

 XML – Wave of the future

 <?xml version = "1.0"?>
 
 <author>
 <name gender = "male">
 <first> Art </first>
 <last> Gittleman </last>
 </name>
 </author>

stack & queue

In this document

More Related Content

What's hot

Viewers also liked

Similar to stack & queue

Recently uploaded

stack & queue