Download queue

Queues
Chapter 4
1
4.2 Queues
 It is a data structure in which the elements are added at
one end, called the rear, and deleted from the other end,
called the front or first.
 A queue is simply a waiting line that grows or shrinks by
adding or taking elements form it.
 Unlike stack, it’s a structure in which both ends are used.
 A queue is an FIFO structure.
 One possible queue implementation is an array(circular
array).
 A more natural queue implementation is a doubly linked
2
list.
 Operations to manage the queue are:
1. Clear()
2. isEmpty()
3. enqueue(el)
4. dequeue()
5. firstEl()
3
Basic Operations on a Queue
 InitializeQueue:
 Initializes the queue to an empty state
 DestroyQueue:
 Removes all the elements from the queue, leaving the
queue empty
 IsEmptyQueue:
 Checks whether the queue is empty. If the queue is
empty, it returns the value true; otherwise, it returns the
value false
 IsFullQueue:
 Checks whether the queue is full. If the queue is full, it
returns the value true; otherwise, it returns the value
false
4
Basic Operations on a Queue
 Front:
 Returns the front (first) element of the queue; the queue
must exist
 Back:
 Returns the last (rear) element of the queue; the queue
must exist
 AddQueue:
 Adds a new element to the rear of the queue; the queue
must exist and must not be full.
 DeleteQueue:
 Removes the front element of the queue; the queue must
exist and must not be empty.
5
 A queue is a linear list in which data can be
inserted at one end, called rear, and deleted from
the other end, called the front. It is a first in-first
out (FIFO) data structure.
 no search,
 no adding in arbitrary positions,
 no sorting,
 no access to anything beyond the front and rear
elements.
6
Basic Queue Operations

Enqueue:
 inserts an element at the rear of the queue.
grape
Data
apple
front
kiwi
rear
queue
7
Enqueue
apple
kiwi
rear
front
operation
grape
queue
Basic Queue Operations

’
cont
Dequeue:
 deletes element at the front of the queue.
apple
Data
apple
kiwi
Dequeue
rear
front
queue
8
grape
operation
kiwi
grape
front
rear
queue
Basic Queue Operations
’
cont
 Queue Front:
 Examines the element at the front of the queue.
apple
Data
apple
kiwi
rear
front
queue
9
grape
Queue
Front
operation
apple
front
kiwi
grape
rear
Basic Queue Operations
’
cont
 Queue Rear:
 Examines the element at the rear of the queue.
grape
Data
apple
kiwi
rear
front
queue
10
grape
Queue
Rear
operation
apple
front
kiwi
grape
rear
Queue Linked List Design
 For a linked list implementation of a queue, we use two
types of structures: a head and a node.
apple
kiwi
grape
fig
rear
front
Conceptual queue
4
front
apple
11
kiwi
count
grape
Physical queue
rear
fig
Queue Linked List Design cont’
4
count
front
rear
Queue head structure
data
node structure
12
next
queueHead
front
<node pointer>
count
<integer>
rear
<node pointer>
end queueHead
node
data
next
end node
<datatype>
<node pointer>
Queue Algorithms
 Create Queue
algorithm createQueue
queue.front = null
2
queue.rear = null
3
queue.count = 0
end createQueue
1
0
front
count
rear
Queue head structure
13
Enqueue
Queue
rear
count
front
0
plum
data
newPtr
next
rear
count
front
Queue
1
newPtr
Before
plum
data
next
After
Case 1: insert into null queue
Queue
front
count
rear
Queue
1
rear
count
front
2
newPtr
plum
data
next
Before
14
plum
data
kiwi
data
next
Case 2: insert into queue
next
After
kiwi
data
next
newPtr
algorithm enqueue
 Enqueue
Insert (push) data into a queue.
Post
dataIn has been inserted
Return true if successful, false if overflow
If (queue full)
1
1
end if
allocate (newptr)
newptr->data = dataIn
newptr->next = null pointer
if (queue.count = zero)
2
3
4
5
6
1
1
9
10
11
15
queue.front = newPtr
else
7
8
return false
queue.rear->next = newPtr
end if
queue.rear
queue.count
return true
end enqueue
= newptr
= queue.count + 1
Dequeue
Queue
rear
count
front
1
plum
data
next
rear
count
front
Queue
0
plum
data
deleteLoc
next
After
Before
Case 1: delete only item in queue
Queue
2
plum
data
next
kiwi
data
Before
16
rear
count
front
next
Queue
deleteLoc
count
front
rear
1
plum
data
next
After
Case 2: delete item at front of queue
kiwi
data
next
algorithm dequeue
 Dequeue
This algorithm deletes a node from a queue.
Post
data at front of queue returned to user
through item and front element deleted and recycled
Return true if successful, false if overflow
If (queue.count is 0)
1
1
end if
Item
= queue.front->data
deleteLoc
= queue.front
if (queue.count is 1)
2
3
4
5
1
6
7
8
9
10
17
return false
queue.rear = null pointer
end if
queue.front
= queue.front->next
queue.count
= queue.count – 1
recycle (deleteLoc)
return true
end dequeue
 Queue Front
algorithm QueueFront
This algorithm receives the data at the front of the queue
without changing the queue contents.
Post
Return
if (queue.count is 0)
1
1
2
3
4
data passed back to caller
true if successful, false if underflow
return false
end if
dataout
return true
end QueueFront
18
= queue.front->data
 Empty Queue
algorithm emptyQueue
This algorithm checks to see if a queue is empty.
Return
1
true if empty, false if queue
return (if queue.count equal 0)
end emptyQueue
19
has data
 Full Queue
algorithm fullQueue
This algorithm checks to see if a queue is full. The
queue is full if memory cannot be allocated for
another node.
Return
true if full, false if there is room for
another node
allocate (tempPtr)
If (allocation successful)
1
2
1
2
else
3
1
4
recycle(tempPtr)
return false
return true
end if
end fullQueue
20
• Queue Count
algorithm Queuecount
Returns the number of elements currently in queue.
1
return queue.count
end Queuecount
21
• Destroy Queue
algorithm destroyQueue
This algorithm deletes all data from a queue.
Post
ptr = queue.front
Loop (ptr not null)
1
2
1
2
3
3
4
5
6
7
all data have been deleted and recycled
deletePtr
= ptr
ptr
= ptr->next
recycle (deletePtr)
end loop
queue.front
queue.rear
queue.count
return
end destroyQueue
22
= null
= null
= 0
Priority Queues
 A priority queue is an ADT with an inserting accessing
protocol: only the highest-priority element can be accessed.
 It is arranged to support access to the highest priority.
 A priority queue stores collection of entries. Each entry is a
(key, value) pair.
 Applications:
 Hospital Emergency Rooms
 Stock market
 Keys in a priority queue can be arbitrary objects on which an
order is defined.
 Two distinct items in a priority queue can have the same key.
23
Priority Queues Methods
 Main methods of the Priority Queue ADT
 insert(k, x) inserts an entry with key k and value x
 removeMin() removes and returns the entry with smallest key
 Additional methods
 minKey(k, x) returns, but does not remove, an entry with
24
smallest key
 minElement() returns, but does not remove, the element of
an item with smallest key
 size()
 isEmpty()
Priority Queue
Suppose that you have a few assignments from different
courses.
Which assignment will you want to work on first?
You set your priority based on due days. Due days are called
keys.
Priority
Due day
Database Systems
2
October 3
UNIX
4
October 10
Data Structure & Algorithm
1
September 29
Structured Systems Analysis
3
October 7
Course
25
 a priority queue is an abstract data type which is like a regular queue or stack
data structure, but where additionally each element has a "priority" associated
with it.
 An entry in a priority queue is simply a (key, value) pair
 In a priority queue, an entry with high priority is served before an entry with
low priority, So the order is determined by key.
 Exe: Highest priority entry will served first ,so it is in the first order: kmin
 The smallest key: If we have a finite number of entries , then the smallest key,
is the key that satisfies kmin< k for any other key k
 If two entries have the same key value, they are served according to their arrival
in the queue.
26
What’s so different?
Stacks and Queues:
• Removal order determined by order of inserting (stack LIFO, Queue FIFO)
Sequences:
• User chooses exact placement when inserting and explicitly chooses removal order
Priority Queue
• Removal order determined by key
• Key may be part of element data or separate
Examples:
 Processes scheduled by CPU
 Hospital Emergency Rooms
 College admissions process for students
27
Priority Queue ADT
 insertItem(k,e): insert element e with key k
 extractMin( )/ removeMin() : return element with minimum key




28
and remove from queue
minElement( ): Return (but do not remove) an element with the
smallest key; an error condition occurs if the priority queue is empty.
minKey( ): Return a smallest key; an error condition occurs if the
priority queue is empty
size( ): return number of elements
isEmpty( ): size == 0?
Priority Queue implementation
1) Implementing PQ with Unsorted Sequence:
 Keys in the sequence are not sorted
 Each call to insertItem(k, e) inserts element in the last of Sequence
 O(1) time
 Each call to extractMin( ) )/ removeMin() traverses the entire sequence to find
the minimum, then removes element
 O(n) time
 What about other operations?
29
Priority Queue implementation
1) Implementing PQ with Unsorted Sequence:
Example: Assume we have the elements stored in an unsorted
sequence show here.
(1,1)
(4,4)
(0,0)
(7,7)
(8,8)
To perform the extractMin()/ removeMin() operation, we have to
inspect all elements to find the element (0,0) that has the smallest key.
30
Priority Queue implementation
2) Implementing PQ with Sorted Sequence:
 Keys in the sequence are sorted
 Each call to insertItem(k, e) traverses sorted sequence to find correct
position, then does insert
 O(n) worst case
 Each call to extractMin( )/removeMin() does remove first element
 O(1) time
 What about other operations?
31
Priority Queue implementation
2) Implementing PQ with Sorted Sequence:
Example:
To insert the pair (6,6), we have to scan through the sequence until we
find the right place (between (4,4) and (7,7)).
(0,0)
(1,1)
(4,4)
(7,7)
(6,6)
32
(8,8)