CH # 4 (Queue)

Data Structures & Algorithms
Chapter # 4
THE QUEUES
By:
Muhammad Imran
Assistant Prof. of Computer Science
Govt. Millat Degree College Mumtazabad, Multan
Lecturer (Visiting Faculty) of I.T

University of Education (Multan Campus) Multan
Ch # 4 (The Queues) 2
Queue
Queue is a linear data structure in which the insertion and deletion operations are
performed at two different ends. In a queue data structure, adding and removing of
elements are performed at two different positions. The insertion is performed at one end
and deletion is performed at other end. In a queue data structure, the insertion operation is
performed at a position which is known as 'rear' and the deletion operation is performed
at a position which is known as 'front'. In queue data structure, the insertion and deletion
operations are performed based on FIFO (First In First Out) principle.
In a queue data structure, the insertion operation is performed using a function called
"enQueue()" and deletion operation is performed using a function called "deQueue()".
Queue data structure can be defined as follows...
Queue data structure is a linear data structure in which the operations are
performed based on FIFO principle.
A queue can also be defined as
"Queue data structure is a collection of similar data items in which insertion and
deletion operations are performed based on FIFO principle".
The structure of Queue is the same as that of a line of a people. A person who wishes to
stand in line must go to the back (rear), and the person in front of the line is served first.
Example
Queue after inserting 25, 30, 51, 60 and 85.
Prepared By: Muhammad Imran

Assistant Prof. of Computer Science, Govt. Millat Degree College, Multan.
Lecturer (Visiting Faculty) of I.T, University of Education Multan Campus.
Basic features of Queue

 Like Stack, Queue is also an ordered list of elements of similar data types.
 Queue is a FIFO( First in First Out ) structure.
 Once a new element is inserted into the Queue, all the elements inserted before the
new element in the queue must be removed, to remove the new element.
 peek( ) function is oftenly used to return the value of first element without
dequeuing it.
Applications of Queue
The purpose of queue is to provide some form of buffering, In computers, the Queues
are used for:
 Process Management: For example in time sharing system processes are added to
a queue and are executed one after the other.
 Buffer between the fast computer and a slow printer: The documents which are
added first in the queue, printed first and vice versa.
Operations on a Queue
The following operations are performed on a queue data structure...
1. enQueue(value) - (To insert an element into the queue)
2. deQueue() - (To delete an element from the queue)
3. display() / peek()- (To display the elements of the queue)

Representation of Queues
Queue data structure can be implemented in two ways. They are as follows...
1. Using Array
2. Using Linked List
When a queue is implemented using array, that queue can organize only limited number
of elements. When a queue is implemented using linked list, that queue can organize
unlimited number of elements.
Queue Using Array

A queue data structure can be implemented using one dimensional array. But, queue
implemented using array can store only fixed number of data values. The implementation
of queue data structure using array is very simple, just define a one dimensional array of
specific size and insert or delete the values into that array by using FIFO (First In First
Out) principle with the help of variables 'front' and 'rear'. Initially both 'front' is set to
0 and 'rear' is set to -1. Whenever, we want to insert a new value into the queue,
increment 'rear' value by one and then insert at that position. Whenever we want to
delete a value from the queue, then increment 'front' value by one and then display the
value at 'front' position as deleted element.
Algorithm - enQueue(value) - Inserting value into the queue

In a queue data structure, enQueue() is a function used to insert a new element into the
queue. In a queue, the new element is always inserted at rear position. The enQueue()
function takes one integer value as parameter and inserts that value into the queue. We
can use the following steps to insert an element into the queue...
public void enqueue(int item)

{
1. check for queue overflow
if (isFull())
{ System.out.println("OverFlow\nProgram Terminated");
System.exit(1);
}
else
rear = (rear + 1) % capacity;
arr[rear] = item;
count++;
}
Algorithm - deQueue() - Deleting a value from the Queue

In a queue data structure, deQueue() is a function used to delete an element from the
queue. In a queue, the element is always deleted from front position. The deQueue()
function does not take any value as parameter. We can use the following steps to delete
an element from the queue.
public void dequeue()
1. check for queue underflow
if (isEmpty())
System.out.println("UnderFlow\nProgram Terminated");
System.exit(1);

else
front = (front + 1) % capacity;
count--;
Circular Queue
In a normal Queue Data Structure, we can insert elements until queue becomes full. But
once if queue becomes full, we cannot insert the next element until all the elements are
deleted from the queue. For example consider the queue below. After inserting all the
elements into the queue.
Now consider the following situation after deleting three elements from the
queue...
This situation also says that Queue is Full and we cannot insert the new element because,
'rear' is still at last position. In above situation, even though we have empty positions in
the queue we cannot make use of them to insert new element. This is the major problem

in normal queue data structure. To overcome this problem we use circular queue data
structure.
What is Circular Queue?

A Circular Queue can be defined as follows...
Circular Queue is a linear data structure in which the operations are performed based on
FIFO (First In First Out) principle and the last position is connected back to the first
position to make a circle. It is also called ‘Ring Buffer’.
Queue operations work as follows:
 Two pointers called FRONT and REAR are used to keep track of the first and last
elements in the queue.

 When initializing the queue, we set the value of FRONT and REAR to -1.
 Enqueue an element, we circularly increase the value of REAR index and place
the new element in the position pointed to by REAR. Before enqueing, we check if
queue is already full.
 Dequeue an element, we return the value pointed to by FRONT and circularly

increase he FRONT index. Before dequeuing, we check if queue is already empty.
 When enqueing the first element, we set the value of FRONT to 0.
 When dequeing the last element, we reset the values of FRONT and REAR to -1.
Algorithm - enQueue(value) - Inserting value into the Circular Queue

In a circular queue, enQueue() is a function which is used to insert an element into the
circular queue. In a circular queue, the new element is always inserted at rear position.
The enQueue() function takes one integer value as parameter and inserts that value into
the circular queue. We can use the following steps to insert an element into the circular
queue...
void enQueue(int item) {
if (((rear + 1) % size) == front) {
System.out.println("Queue is full");
} else {
if (rear == front && front == -1) {
front = 0;
rear = (rear + 1) % size;
qArray[rear] = item;
Algorithm - deQueue() - Deleting a value from the Circular Queue

In a circular queue, deQueue() is a function used to delete an element from the circular
queue. In a circular queue, the element is always deleted from front position. The
deQueue() function doesn't take any value as parameter. We can use the following steps
to delete an element from the circular queue...
void deQueue() {
if (rear == front && rear == -1)
System.out.println("Queue is empty.");
else {
int item = qArray[front];
qArray[front] = 0;//reset data
if (rear == front) {//Queue is empty
rear = -1;
front = -1;
else {
front = (front + 1) % size;
System.out.println(item + " is dequeued from the Queue");

Double Ended Queue (Dequeue)

Double Ended Queue is also a Queue data structure in which the insertion and deletion
operations are performed at both the ends (front and rear). That means, we can insert at
both front and rear positions and can delete from both front and rear positions.
Double Ended Queue can be represented in TWO ways, those are as follows...
1. Input Restricted Double Ended Queue
2. Output Restricted Double Ended Queue
1. Input Restricted Double Ended Queue

In input restricted double ended queue, the insertion operation is performed at only one
end and deletion operation is performed at both the ends.

2. Output Restricted Double Ended Queue
In output restricted double ended queue, the deletion operation is performed at only one
end and insertion operation is performed at both the ends.
Basic Deque Operations
The following are the basic operations that can be performed on deque.
 insert front: Insert or add an item at the front of the deque.
 insertLast: Insert or add an item at the rear of the deque.
 deleteFront: Delete or remove the item from the front of the queue.
 delete last: Delete or remove the item from the rear of the queue.
 getFront: Retrieves the front item in the deque.
 getLast: Retrieves the last item in the queue.
 isEmpty: Checks if the deque is empty.
 isFull: Checks if the deque is full.

Deque Illustration
An empty deque is represented as follows:
Next, we insert element 1 at the front.
Now, we insert element 3 at the rear.
Next, we add element 5 to the front and when incremented the front points to 4.
Then, we insert elements 7 at the rear and 9 at the front. The deque will look as shown below.

Next, let us remove an element from the front.


CH # 4 (Queue)

Uploaded by

Copyright:

Available Formats

You might also like

CH # 4 (Queue)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CH # 4 (Queue)

Uploaded by

Copyright:

Available Formats

Data Structures & Algorithms

Lecturer (Visiting Faculty) of I.T

Queue data structure can be defined as follows...

A queue can also be defined as

Queue after inserting 25, 30, 51, 60 and 85.

Prepared By: Muhammad Imran

Basic features of Queue

 Queue is a FIFO( First in First Out ) structure.

1. enQueue(value) - (To insert an element into the queue)

2. deQueue() - (To delete an element from the queue)

3. display() / peek()- (To display the elements of the queue)

Prepared By: Muhammad Imran

2. Using Linked List

Queue Using Array

Algorithm - enQueue(value) - Inserting value into the queue

public void enqueue(int item)

Algorithm - deQueue() - Deleting a value from the Queue

public void dequeue()

1. check for queue underflow

Prepared By: Muhammad Imran

front = (front + 1) % capacity;

Prepared By: Muhammad Imran

What is Circular Queue?

Queue operations work as follows:

Prepared By: Muhammad Imran

 Dequeue an element, we return the value pointed to by FRONT and circularly

 When enqueing the first element, we set the value of FRONT to 0.

Algorithm - enQueue(value) - Inserting value into the Circular Queue

void enQueue(int item) {

if (((rear + 1) % size) == front) {

if (rear == front && front == -1) {

rear = (rear + 1) % size;

Algorithm - deQueue() - Deleting a value from the Circular Queue

if (rear == front && rear == -1)

int item = qArray[front];

qArray[front] = 0;//reset data

if (rear == front) {//Queue is empty

front = (front + 1) % size;

System.out.println(item + " is dequeued from the Queue");

Prepared By: Muhammad Imran

Double Ended Queue (Dequeue)

1. Input Restricted Double Ended Queue

2. Output Restricted Double Ended Queue

1. Input Restricted Double Ended Queue

Prepared By: Muhammad Imran

2. Output Restricted Double Ended Queue

Basic Deque Operations

 insert front: Insert or add an item at the front of the deque.

 insertLast: Insert or add an item at the rear of the deque.

 getFront: Retrieves the front item in the deque.

 getLast: Retrieves the last item in the queue.

 isEmpty: Checks if the deque is empty.

 isFull: Checks if the deque is full.

Prepared By: Muhammad Imran

Next, we insert element 1 at the front.

Now, we insert element 3 at the rear.

Prepared By: Muhammad Imran

Next, let us remove an element from the front.