Data Structures & Algorithms
Dated: 06-12-2010
Today Topics
What are Queues?
Representation of Queues
Operations on Queues
QInsert
QDelete
What are Queues?
Queue can be defined as:
A queue is an ordered collection of items
from which items may be deleted at one
end (called the front of the queue) and into
which items may be inserted at the other
end (called the rear of the queue).
A queue is a waiting line – seen in daily life
A line of people waiting for a bank teller
A line of cars at a toll both
queue
Features:
A list structure with two access points called the
front and rear.
All insertions (enqueue) occur at the rear and
deletions (dequeue) occur at the front.
Varying length (dynamic).
Homogeneous components
Has a First-In, First-Out characteristic (FIFO)
application
Application of Queue
Purpose of queue is to provide some form
of buffering. Queues are used for:
Process Management: In timesharing
system, programs are added to a queue
and executed one after the other.
Buffer between the fast computer and a
slow printer.
In queues, scheme used is FIFO or LILO
implementation of Queues
There are two ways of implementing a queue:
Array (Static)
Link List (Dynamic)
A queue can be implemented with an array and
two integers.
The first integer front used for deletion item
from queue and rear used for insert item in
queue
Array Implementation
How to implement queue
Decide how many data member are needed to
implement the queue.
We need at least four types of variable.
An array to store the element
Variables queuefront to keep track of the first element
Queuerear to keep track of the last elelment.
Maxsize variable
How to use rear and front to access the queue
element.????
How they indicate that queue is full or empty.
Bounds of Queue
If FRONT: = NULL “empty”
If REARE := NUL “empty”
If REARE := N “overflow, full”
If FRONT=REARE != NULL then the
queue contain only one element.
If FRONT = REARE???????? Very
interesting situation.
Representation of Queues
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
34 12 53 61 9 23 -8 15 24 42
front rear
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
front = 0 rear = 0
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
32
front
rear QInsert(32)
front = 1 rear = 1
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
32 44
front rear
QInsert(44)
front = 1 rear = 2
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
32 44 65
front rear
QInsert(65)
front = 1 rear = 3
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
32 44 65 25
front rear
QInsert(25)
front = 1 rear = 4
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
32 44 65 25 53
front rear
QInsert(53)
front = 1 rear = 5
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
44 65 25 53
front rear
QDelete()
front = 2 rear = 5
Queues Working
Currently Queue Status
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
65 25 53
front rear
QDelete()
front = 3 rear = 5
Think about it
What happen when
Rear= 10
Front = 9
????????? And you want to insert.
Two solution::::::
Check the front, if there is room then slides
all the element to fist position, but well
when queue is small.
Use circular array.
In case of circular queue how to
set rear point
Rear= (rear + 1) % maxsize; how???????
If Rear < maxsize -1, then
Rear + 1 <= mzxsize -1 and so
(Rear +1) % maxsize= Rear + 1.
If Rear == maxsize -1 (that is rear point to the
last position) then
Rear + 1 == maxsize and so
(Rear + 1) % maxsize==0. in this case Rear is set to 0.
And same can be done for Front adjustment.
Operations on Queue
Generally, Queue is implemented with only
two principle operations
InitializeQueue queue to an empty state
destroyQuere revome all the elements
isEmpthyQueue
isFullQueue
Front
rear
Insertion: adds an item to a queue
Deletion: delete an item from the queue
Algorithms of Insert Operation
QINSERT(QUEUE, N, FRONT, REAR, ITEM)
This algorithm insert an element ITEM into a queue.
Setp1. [Queue already filled]
if FRONT := 1 and REAR:= N,
write “overflow” and return
Step 2. [Find new value of REAR]
if FRONT := NULL [Queue initially empty]
Set FRONT:= 1 and REAR:= 1
Else if REAR:=N than
Set REAR:=1
Else
Set REAR:=REAR+1
[End of if structure]
Step 3. Set QUEUE[REAR]:=ITEM [this insert new item ]
Step 4. exit
Algorithms of Insert Operation
QInsert (X)
Algorithm for Insert element into the Queue
1. Start
2. if rear >= Max then
Print “Queue Overflow!”
else
rear = rear + 1
Q[rear] = X
if front = 0 then
front = 1
end if
end if
End
Algorithms of DELETE Operation
QDELETE(QUEUE, N, FRONT, REAR, ITEM)
This algorithm delete an element ITEM into a queue.
Setp1. [Queue already empty]
if FRONT := NULL write “UNDERFLOW”
return
Step 2. set ITEM:= QUEUE[FORNT]
Step 3. [Find new value of FRONT]
if FRONT := REAR than [Queue has only one element]
Set FRONT:= NULL and REAR:= NULL
Else if FRONT:=N than
Set FRONT;=1
Else
Set FRONT:=FRONT+1
[End of if structure]
Step 5. exit
Algorithms of Delete Operation
QDelete ()
Algorithm for delete element into the Queue
1. Start
2. if front = 0 then
Print “Queue Underflow!”
else
E = Q[front]
if front = rear then
front = rear = 0
else
front = front + 1
end if
end if
3. End
Circular Queue
When elements are deleted from the front, their spaces
cannot be used to store new elements.
To solve this problem, circular queue is used
Q[8] Q[1]
Q[7] Q[2]
Q[6] Q[3]
Q[5] Q[4]
Algorithms of CQInsert Operation
CQInsert (X)
Algorithm for Insert element into the Circular Queue
1. Start
2. if front = 1 and rear = Max then
Print “Queue Overflow!”
else if rear + 1 = front then
Print “Queue Overflow!”
else
if front = 0 and rear=0 then
front = rear = 1
else if rear = Max then
rear = 1
else
rear = rear + 1
end if
Q[rear] = X
end if
End
Algorithms of CQDelete Operation
CQDelete ()
Algorithm for delete element into the Circular Queue
1. Start
2. if front = 0 then
Print “Queue Underflow!”
else
E = Q[rear]
if front = rear then
front = rear = 0
else if front = Max then
front = 1
else
front = front + 1
end if
end if
End
DeQue
Word deque is a short form of double-ended queue.
Deque defines a data structure in which item can be added or deleted at either the front or rear end.
But no changes can be made elsewhere in the list.
Deque is a generalization of both a stack and a queue.
DeQue
There are two variations of deques. These are:
Input – Restricted Deque
It allows insertions only at one end but allows
deletions at both ends.
Output – Restricted Deque
It allows deletions only at one end but allows
insertions at both end
Representation of Deque
delete delete
insert insert
a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10]
34 12 53 61 9 23 -8 15 24 42
front Deque rear
Implementation of Deque
When an item is inserted at the Front of
DEQ, then front is decreased by 1.
When an item is inserted at the Rear of
DEQ, then rear is increased by 1.
When an item is deleted at the Front of
DEQ, then front is increased by 1.
When an item is deleted at the Rear of
DEQ, then rear is decreased by 1.
Implementation of Deque
In the following figure, the DEQ has some
items stored in it
Front X Y Z Rear
Deque
front = 2 rear = 4
The first element at the front of the deque
is empty and two elements at the rear are
also empty.
Implementation of Deque
If another item XX is added at the rear,
then the DEQ and values of front and rear
will be :
Front X Y Z XX Rear
Deque
front = 2 rear = 5
Implementation of Deque
If two items are deleted at the front and
one item is deleted at the rear, then the
DEQ and values of front and rear will be:
Front Z Rear
Deque
front = 4 rear = 4
Algorithms of DeQInsert Operation
DeQInsert (X, Side)
Algorithm for Insert element into the Deque
1. Start
2. if front = 0 and rear = 0 then
front = rear = 1
DQ[front] = X
Return
end if
[specify front or rear side to insert value]
3. [insert value at front of the queue] if Side = 1 then
if front > 1 then
front = front – 1
DQ[front] = X
else
Print “No space at front of the Deque!”
Algorithms of DeQInsert Operation
end if
else
if rear < Max then
rear = rear + 1
DQ[rear] = X
else
Print “No space at rear of the Deque!”
end if
end if
4. End
Algorithms of DeQDelete Operation
DeQDelete (Side)
Algorithm for delete element into the Deque
1. Start
2. If front = 0 and rear = 0 then
Print “DeQueue Underflow!”
Return
end if
3. if front = rear then
E= DQ[front]
front = rear = 0
Return
end if
Algorithms of DeQDelete Operation
4. if Side = 1 then
if front = Max then
E = DQ[front]
front = 0
else
E = DQ[front]
front = front + 1
end if
else
E = DQ[rear]
rear = rear - 1
end if
5. End
Priority Queues
Priority queue is a collection of elements where the
elements are stored according to their priority levels.
The order in which the elements should get added or
removed is decided by the priority of the element.
Following rules are applied to maintain a priority queue:
The element with a higher priority is processed before
any element of lower priority.
If there are elements with the same priority, then the
element added first in the queue would get processed.
Example for Priority Queues
Priority queues are used for implementing job
scheduling by the operating system where jobs
with higher priorities are to be processed first.
Another application of priority queues is
simulation systems where priority corresponds
to event times.
Representation of Priority Queues
Priority queues can be represented in the
several ways.
Best way to represent it is to use a separate
queue for each level of priority.
Each such queue is represented in circular
fashion and has its own front and rear.
Representation of Priority Queues
Usually, an array of arrays, i.e. a two-dimensional array
is used to represent.
1 X Y
2 A B C
3 M N O P
4
Next Lecture
Pointer Review
Linked List
Representation of Link List
Operations of Linked List
Circular Linked List
Double Linked List (Two-Way List)
Representation of Double Linked List
Operations of Double Linked List
