Download week4- STACKS N QUEUES

Stacks and Queues
DSA 2013 Stacks n Queues
A Different Kind of Structure
• There are significant differences between the data structures
and algorithms of Arrays and that for Stacks & Queues. We’ll
discuss three differences:
1. Programmer’s Tools
• Arrays—as well as many other structures (linked lists, trees,
etc.) are appropriate for the kind of data you might find in a
database application.
• They’re typically used for personnel records, inventories,
financial data, etc.—data that corresponds to real-world
objects or activities.
• These structures facilitate access to data: they make it easy to
insert, delete, and search for particular items.
DSA 2013 Stacks n Queues
A Different Kind of Structure
• Stacks and Queues, on the other hand, are more often used
as programmer’s tools.
• They’re primarily conceptual aids rather than full-fledged data
storage devices.
• Their lifetime is typically shorter than that of the databasetype structures.
• They are created and used to carry out a particular task during
the operation of a program; when the task is completed,
they’re discarded.
DSA 2013 Stacks n Queues
A Different Kind of Structure
2. Restricted Access
• In an array, any item can be accessed, either immediately—if its
index number is known—or by searching through a sequence of
cells until it’s found.
• In Stacks and Queues, however, access is restricted: Only one
item can be read or removed at a given time.
3. More Abstract
• Stacks and queues are more abstract entities than arrays and
many other data storage structures. The underlying mechanism
used to implement them is typically not visible to their user.
• The underlying mechanism for a stack, for example, can be an
array or a linked list. The underlying mechanism for a priority
queue can be an array or a special kind of tree called a heap.
DSA 2013 Stacks n Queues
Stacks
DSA 2013 Stacks n Queues
Abstract Data Types (ADTs)
• An abstract data type (ADT) is an abstraction of
a data structure
• An ADT specifies:
– Data stored
– Operations on the data
– Error conditions associated with operations
DSA 2013 Stacks n Queues
Abstract Data Types (ADTs)
• Example: ADT modeling a simple stock trading
system
– The data stored are buy/sell orders
– The operations supported are
• order buy(stock, shares, price)
• order sell(stock, shares, price)
• void cancel(order)
– Error conditions:
• Buy/sell a nonexistent stock
• Cancel a nonexistent order
DSA 2013 Stacks n Queues
The Stack ADT
• A stack is a list with the restriction
– that insertions and deletions can only be performed at
the top of the list
• Stacks are less flexible
 but are more efficient and easy to implement
• Stacks are known as LIFO (Last In, First Out) lists.
– Insertions and deletions follow the last-in first-out
scheme
– The last element inserted will be the first to be
retrieved
DSA 2013 Stacks n Queues
The Stack ADT
• Think of a spring-loaded plate dispenser
• Main stack operations:
– Push: inserts an element to the top of the stack
– Pop: removes and returns the last inserted element
• Auxiliary stack operations:
– Top: returns the last inserted element without
removing it
– integer Size: returns the number of elements stored
– boolean isEmpty: indicates whether no elements are
stored
DSA 2013 Stacks n Queues
Stack
top
Stack
DSA 2013 Stacks n Queues
THE CONCEPT OF STACK
– Consider this stack: values are stored and
retrieved in "last in first out" manner by using
operations push and pop.
DSA 2013 Stacks n Queues
Exceptions
• Attempting the execution of an operation may
sometimes cause an error condition, called an
exception
• Exceptions are said to be “thrown” by an operation
that cannot be executed
• In the Stack ADT, operations pop and top cannot be
performed if the stack is empty
• Attempting the execution of pop or top on an
empty stack throws an EmptyStackException
DSA 2013 Stacks n Queues
Applications of Stacks
• Direct applications
– Page-visited history in a Web browser
– Undo sequence in a text editor
– Chain of Method calls in the Java Virtual Machine
DSA 2013 Stacks n Queues
Method Stack in the JVM
• The Java Virtual Machine (JVM)
keeps track of the chain of active
methods with a stack
• When a method is called, the JVM
pushes on the stack a frame
containing
– Local variables and return value
– Program counter, keeping track of
the statement being executed
• When a method ends, its frame is
popped from the stack and
control is passed to the method
on top of the stack
DSA 2013 Stacks n Queues
main() {
int i = 5;
foo(i);
}
foo(int j) {
int k;
k = j+1;
bar(k);
}
bar(int m) {
…
}
bar
PC = 1
m=6
foo
PC = 3
j=5
k=6
main
PC = 2
i=5
Implementation of Stacks
• need an underlying collection to hold the elements
of the stack
• 2 basic choices
– Arrays (static: the size of stack is given initially)
– Linked lists (dynamic: never become full)
DSA 2013 Stacks n Queues
Array Implementation of Stack
• A simple way of implementing the Stack ADT uses an array
• Need to declare an array size ahead of time
• A variable keeps track of the index of the top element, say,
TopOfStack
– for an empty stack, set TopOfStack to -1
• Push
– (1) Increment TopOfStack by 1.
– (2) Set Stack[TopOfStack] = X
• Pop
– (1) Set return value to Stack[TopOfStack]
– (2) Decrement TopOfStack by 1
• These operations are performed in very fast constant time
DSA 2013 Stacks n Queues
Array-based Stack
• For Stack S and
TopofStack t :
Algorithm size()
return t + 1
Algorithm pop()
if isEmpty() then
throw EmptyStackException
else
tt1
return S[t + 1]
…
S
0
1
2
t
DSA 2013 Stacks n Queues
Array-based Stack (cont.)
• The array storing the
stack elements may
become full
• A push operation will
then throw a
FullStackException
– Limitation of the arraybased implementation
– Not built-in to the Stack
ADT
Algorithm push(o)
if t = S.length  1 then
throw FullStackException
else
tt+1
S[t]  o
…
S
0
1
2
t
DSA 2013 Stacks n Queues
Performance and Limitations
• Performance
– Let n be the number of elements in the stack
– The space used is O(n)
– Each operation runs in constant time O(1)
That is, the time is not dependent on how many items are in the stack and is
therefore very quick. No comparisons or moves are necessary.
• Limitations
– The maximum size of the stack must be defined ahead
of time and cannot be changed
– Trying to push a new element into a full stack causes
an implementation-specific exception
DSA 2013 Stacks n Queues
Parentheses Matching
• In processing programs and working with computer
languages there are many instances when symbols
must be balanced
• Each “(”, “{”, or “[” must be paired with a matching
“)”, “}”, or “[”
–
–
–
–
correct: ( )(( )){([( )])}
correct: ((( )(( )){([( )])}
incorrect: )(( )){([( )])}
incorrect: ({[ ])}
• A stack is useful for checking symbol balance. When
a closing symbol is found it must match the most
recent opening symbol of the same type. Algorithm?
DSA 2013 Stacks n Queues
Algorithm for Balanced Symbol Checking
• Make an empty stack
• read symbols until end of file
– if the symbol is an opening symbol push it onto the
stack
– if it is a closing symbol do the following
• if the stack is empty report an error
• otherwise pop the stack. If the symbol popped does not
match the closing symbol report an error
• At the end of the file if the stack is not empty
report an error
DSA 2013 Stacks n Queues
Parentheses Matching Algorithm
Algorithm ParenMatch(X,n):
Input: An array X of n tokens, each of which is either a grouping symbol, a
variable, an arithmetic operator, or a number
Output: true if and only if all the grouping symbols in X match
Let S be an empty stack
for i=0 to n-1 do
if X[i] is an opening grouping symbol then
S.push(X[i])
else if X[i] is a closing grouping symbol then
if S.isEmpty() then
return false {nothing to match with}
if S.pop() does not match the type of X[i] then
return false {wrong type}
if S.isEmpty() then
return true {every symbol matched}
else
return false {some symbols were never matched}
DSA 2013 Stacks n Queues
Queues
DSA 2013 Stacks n Queues
Queue ADT
• Like a stack, a queue is also a list.
• However, with a queue, insertion is done at one end, while
deletion is performed at the other end.
• Accessing the elements of queues follows a First In, First Out
(FIFO) order.
– the first element added to the queue will be the first one to be
removed
– Like customers standing in a check-out line in a store, the first
customer in is the first customer served.(or at a Bank)
• Add items to the back (rear) of the queue
• Access and remove from the front
• Used extensively in operating systems
– Queues of processes, I/O requests, and much more
DSA 2013 Stacks n Queues
Enqueue and Dequeue
• Basic operations:
– Enqueue: insert an element at the rear of the list
– Dequeue: remove the element at the front of the list
Remove
(Dequeue)
front
rear
DSA 2013 Stacks n Queues
Insert
(Enqueue)
Queue Example
Operation
enqueue(5)
enqueue(3)
dequeue()
enqueue(7)
dequeue()
front()
dequeue()
dequeue()
isEmpty()
enqueue(9)
enqueue(7)
size()
enqueue(3)
enqueue(5)
dequeue()
Output
Q
–
–
5
–
3
7
7
“error”
true
–
–
2
–
–
9
(5)
(5, 3)
(3)
(3, 7)
(7)
(7)
()
()
()
(9)
(9, 7)
(9, 7)
(9, 7, 3)
(9, 7, 3, 5)
(7, 3, 5)
DSA 2013 Stacks n Queues
Applications of Queues
• Direct applications
– Waiting lists, bureaucracy
– Access to shared resources (e.g., printer)
– Multiprogramming
DSA 2013 Stacks n Queues
Implementation of Queue
• Just as stacks can be implemented as arrays or
linked lists, so with queues.
• Dynamic queues have the same advantages
over static queues as dynamic stacks have
over static stacks
DSA 2013 Stacks n Queues
Queue Implementation of Array
• There are several different algorithms to
implement Enqueue and Dequeue
• Naïve way
– When enqueuing, the front index is always fixed
and the rear index moves forward in the array.
rear
rear
3
3
front
front
Enqueue(3)
6
Enqueue(6)
DSA 2013 Stacks n Queues
rear
3
6
front
Enqueue(9)
9
Queue Implementation of Array
• Naïve way
– When dequeuing, the element at the front the
queue is removed. If the front index is always
fixed, then we have to move all the elements
after it by one position. (Inefficient!!!)
6
rear
rear
9
9
front
Dequeue()
front
Dequeue()
DSA 2013 Stacks n Queues
rear = -1
front
Dequeue()
Queue Implementation of Array
• Better way
• Instead, we keep the items in the same place and
move the front and rear of the queue.
(front) XXXXOOOOO
OXXXXOOOO
OOXXXXXOO
OOOOXXXXX
(rear)
(after 1 dequeue, and 1 enqueue)
(after 2 dequeues, and 3 enqueues)
(after 4 dequeues, and 5 enqueues)
• The trouble with this arrangement is that soon the rear of the
queue is at the end of the array (the highest index).
DSA 2013 Stacks n Queues
A Circular Queue
• Even if there are empty cells at the beginning of the
array, because you’ve removed them , you still can’t
insert a new item because Rear can’t go any further.
Wrapping around
To avoid the problem of not being able to insert more
items into the queue even when it’s not full, the
Front and Rear arrows wrap around to the beginning
of the array.
• The result is a circular queue
DSA 2013 Stacks n Queues
Implementation using Circular Array
• Using a circular array
• When an element moves past the end of a
circular array, it wraps around to the beginning,
e.g.
– OOOOO7963  4OOOO7963 (after Enqueue(4))
– After Enqueue(4), the rear index moves from pointing
to 3 and points to 4.
DSA 2013 Stacks n Queues
DSA 2013 Stacks n Queues
Implementation
Array-based Queue
• Use an array of size N in a circular fashion
• Two variables keep track of the front and rear
f index of the front element
r index immediately past the rear element
• Array location r is kept empty
normal configuration
Q
0 1 2
f
r
wrapped-around configuration
Q
0 1 2
r
f
DSA 2013 Stacks n Queues
Queue Operations
• We use the modulo Algorithm size()
return (N  f + r) mod N
operator
(remainder of
Algorithm isEmpty()
division)
return (f = r)
Q
0 1 2
f
0 1 2
r
r
Q
f
DSA 2013 Stacks n Queues
Queue Operations (cont.)
• Operation enqueue
throws an exception if
the array is full
• This exception is
implementationdependent
Algorithm enqueue(o)
if size() = N  1 then
throw FullQueueException
else
Q[r]  o
r  (r + 1) mod N
Q
0 1 2
f
0 1 2
r
r
Q
f
DSA 2013 Stacks n Queues
Queue Operations (cont.)
• Operation dequeue
throws an exception if
the queue is empty
• This exception is
specified in the queue
ADT
Algorithm dequeue()
if isEmpty() then
throw EmptyQueueException
else
o  Q[f]
f  (f + 1) mod N
return o
Q
0 1 2
f
0 1 2
r
r
Q
f
DSA 2013 Stacks n Queues
Deques
• A deque is a double-ended queue.
• You can insert items at either end and delete them from
either end. The methods might be called insertLeft() and
insertRight(), and removeLeft() and removeRight().
• If you restrict yourself to insertLeft() and removeLeft() (or
their equivalents on the right), the deque acts like a
stack. If you restrict yourself to insertLeft() and
removeRight() (or the opposite pair), it acts like a queue.
• A deque provides a more versatile data structure than
either a stack or a queue. However, it’s not used as often
as stacks and queues, so we won’t explore it further.
DSA 2013 Stacks n Queues
Priority Queues
• A priority queue is a more specialized data structure
than a stack or a queue.
• Like an ordinary queue, a priority queue has a front
and a rear, and items are removed from the front.
• However, in a priority queue, items are ordered by
key value so that the item with the lowest key (or the
highest key) is always at the front.
• Items are inserted in the proper position to maintain
the order.
DSA 2013 Stacks n Queues
Priority Queue Implementation
• A priority queue can be implemented by a
sorted array or a special kind of tree called a
heap (we’ll see this later).
• Performance:
– insert takes O(n) time since we have to find the
place where to insert the item
– delete takes O(1) time, since the smallest key is at
the beginning
DSA 2013 Stacks n Queues
Priority Queue Applications
• Like stacks and queues, priority queues are often
used as programmer’s tools. We’ll see one used in
finding something called a minimum spanning tree
for a graph later
Priority-based OS process scheduler
• Priority queues are used in various ways in certain
computer systems. In a multitasking operating
system, for example, programs may be placed in a
priority queue so the highest-priority program is the
next one to execute.
DSA 2013 Stacks n Queues
Efficiency of Stacks & Queues
• Items can be both pushed and popped from
the stack in constant O(1) time. That is, the
time is not dependent on how many items are
in the stack and is therefore very quick. No
comparisons or moves are necessary.
• As with a stack, items can be inserted and
removed from a queue in O(1) time.
DSA 2013 Stacks n Queues