IT2070 – Data Structures and Algorithms

Lecture 02
Introduction to Queue

Module Code | Module Name | Lecture Title | Lecturer

Data Structures and Algorithms

Queues

 Imagine a queue in real life 

 The first item inserted is the first item to be removed

2
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queues

 In a queue all insertions are made at the Rear end and deletions are made at the Front
end.
 Insertions and deletions are restricted from the Middle of the Queue.

 Adding an item is called insert

 Removing an item is called remove

 The elements are inserted and removed according to the First-In-First-Out (FIFO) principle.

3
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue - Insert

0 1 2 3 4 5 0 1 2 3 4 5 0 1 2 3 4 5
15 27 39 23 15 27 39 23 15 27 39 23 45

Front Rear Front Rear 45 Front Rear

New Element
(Insert)

Before inserting Item 45 is inserted to the rear After inserting

4
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue - Remove

0 1 2 3 4 5 0 1 2 3 4 5 0 1 2 3 4 5
15 27 39 23 15 27 39 23 27 39 23

Front Rear Front Rear Front Rear

15

Before removing Front item is removed After removing

5
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue - PeekFront

0 1 2 3 4 5 0 1 2 3 4 5
15 27 39 23 15 27 39 23
Peek  15

Front Rear Front Rear

Queue remains the same

Peek is used to read the value from the Front of the queue without
removing it. You can peek only the Front item, all the other items are
invisible to the queue user.

6
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Question 01
Draw the Queue frame after performing the below operations to the queue given
below.

0 1 2 3 4 5 6
60 47 99 67 24

e of
Front Rear siz 7
s
um ue i
xim ue
a
i) Insert item 33 M is q
ii) Insert item 53 th
iii) peekFront
iv) remove
v) remove
vi) remove
vii) remove
viii) remove
7
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Uses of Queue

 There are various queues quietly doing their job in a

computer’s operating system.

 printer queue
 stores keystroke data as you type at the keyboard
 pipeline

8
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue - Implementation
Queue implementation using an array with restricted access
 Constructor creates a new Queue class QueueX {
private int maxSize; // size of queue array
of a size specified in its argument. private int [] queArray;
private int front; //front of the queue
 Variable front, which stores the private int rear; //rear of the queue
index of the item on the front of the private int nItems; //no of items of the queue
queue. publc QueueX (int s) {// constructor

 Variable rear, which stores the maxSize = s; // set array size

index of the item on the end of the queArray = new int [maxSize];
front = 0;
queue. rear = -1;
nItems = 0; // no items
 Variable nItems, which stores the }
total number of the items in the …………………….
…………………….
queue. }
9
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue – Implementation - insert

class QueueX {
private int maxSize; // size of queue array
private int [] queArray;
private int front; //front of the queue
private int rear; //rear of the queue
private int nItems; //no of items of the queue

publc QueueX(int s) { // constructor

maxSize = s; // set array size

queArray = new int [maxSize];
front = 0;
rear = -1;
nItems = 0; // no items
}
public void insert(int j) {
// increment rear
// insert an item
}
}
10
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue – Implementation - insert

class QueueX {
private int maxSize; // size of queue array
private int [] queArray;
private int front; //front of the queue
private int rear; //rear of the queue
private int nItems; //no of items of the queue

publc QueueX(int s) { // constructor

maxSize = s; // set array size

queArray = new int [maxSize];
ll ?
u
front = 0;
isf
rear = -1; e
nItems = 0; // no items u eu
} e q
h
public void insert(int j) { ift
t
// increment rear and insert an item ha
W
queArray[++rear] = j;
nItems++;
}
}
11
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue – Implementation - insert

class QueueX {
private int maxSize; // size of queue array public void insert(int j) {
private int [] queArray;
private int front; //front of the queue
// check whether queue is full
private int rear; //rear of the queue
private int nItems; //no of items of the queue
if (rear == maxSize – 1)
System.out.println(“Queue is full”);
publc QueueX(int s) {// constructor
else {
maxSize = s; // set array size
queArray = new int [maxSize]; queArray[++rear] = j;
front = 0;
rear = -1; nItems++;
nItems = 0; // no items
}
}
}
}

12
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue – Implementation – remove/peekFront

class QueueX {
private int maxSize; // size of queue array public int remove() {
private int [] queArray;
private int front; //front of the queue
// check whether queue is empty
private int rear; //rear of the queue
private int nItems; //no of items of the queue
// if not
// access item and increment
publc QueueX(int s) { // constructor
front
maxSize = s; // set array size
queArray = new int [maxSize]; }
front = 0;
rear = -1;

}
nItems = 0; // no items
public int peekFront() {
public void insert(int j) { // check whether queue is empty
// check whether queue is full // if not
if (rear == maxSize – 1)
System.out.println(“Queue is full”); // access item
else {
}
queArray[++rear] = j;
nItems++;

}
}
}

13
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue – Implementation – remove

class QueueX{
private int maxSize; // size of queue array
public int remove() {
private int [] queArray; if (nItems == 0) {
private int front; //front of the queue
private int rear; //rear of the queue System.out.println(“Queue is empty”);
private int nItems; //no of items of the queue
return -99;
publc QueueX(int s) {// constructor }
maxSize = s; // set array size else {
queArray = new int [maxSize];
front = 0;
nItems--;
rear = -1; return queArray[front++];
nItems = 0; // no items
} }
public void insert(int j) {
}
// check whether queue is full
if (rear == maxSize – 1)
System.out.println(“Queue is full”);
else {

queArray[++rear] = j;
nItems++;

}
}
14
}
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Queue – Implementation – peekFront

class QueueX{
private int maxSize; // size of queue array
public int peekFront() {
private int [] queArray; if (nItems == 0) {
private int front; //front of the queue
private int rear; //rear of the queue System.out.println(“Queue is empty”);
private int nItems; //no of items of the queue
return -99;
publc QueueX(int s) {// constructor }
maxSize = s; // set array size else {
queArray = new int [maxSize];
front = 0;
return queArray[front];
rear = -1; }
nItems = 0; // no items
} }
public void insert(int j) {

// check whether queue is full

if (rear == maxSize – 1)
System.out.println(“Queue is full”);
else {

queArray[++rear] = j;
nItems++;

}
}
15
}
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Question 02

isEmpty() method of the Queue class returns true if the Queue is empty and
isFull() method returns true if the Queue is full.

Implement isEmpty() and isFull() methods of the Queue class.

16
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Question 03
Draw the Queue frame after performing the below operations to the queue given below.

0 1 2 3 4 5 6
67 12 22 55 34 70 60

Front Rear

i) remove
ii) remove
iii) remove
iv) Insert item 88

17
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Question 03 Contd..

Draw the Queue frame after performing the below operations to the queue given below.

0 1 2 3 4 5 6 0 1 2 3 4 5 6
77 67
67 12 1222 2255 55 3434 7070 60
60 77 67 12 2255 55 3434 7070 60
60

Front Rear Front Rear

i) remove Although the queue is not full we

ii)
iii)
remove
remove
cannot insert more elements.
iv) Insert item 88
Any Suggestions?

18
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

How to overcome this situation??

We can use a Circular Queue

0 0 1 6
2 3 4 5
77 67 12 2255 55 3434 7070 60
60
Rear
6 60 1
Front Rear

70
5 2
34 55
Front
4 3

19
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Circular Queue

 Circular queues are queues that wrap around themselves.

 These are also called ring buffers.

 The problem in using the linear queue can be overcome by using circular
queue.

 When we want to insert a new element we can insert it at the beginning of

the queue.

i.e. if the queue is not full we can make the rear start from the beginning
by wrapping around

If rear was 3 then the next element should be stored in index 4

If rear was 7 then the next element should be stored in index 0
20
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Question 04
Draw the Queue frame after performing the below operations to the circular queue
given below.

i) insert(14);
ii) insert(29);
iii) insert(33);
iv) insert(88);
v) peekFront();
vi) remove();
vii) remove();
viii) insert(90);
ix) insert(100);
x) peekFront();

21
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Inserting an element to Inserting an element to

Linear Queue Circular Queue
public void insert(int j) { public void insert(int j) {
// check whether queue is full // check whether queue is full
if ( rear == maxSize - 1) if (nItems == maxSize)
System.out.println(“Queue is full”);
System.out.println(“Queue is full”);
else {
queArray[++rear] = j; else {
nItems++; if(rear == maxSize - 1)
rear = -1;
}
} queArray[++rear] = j;

nItems++;
}
}

22
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Removing an element Removing an element

from Linear Queue from Circular Queue
public int remove() { public int remove() {
// check whether queue is empty
// check whether queue is empty
if ( nItems == 0)
System.out.println(“Queue is empty”); if ( nItems == 0)
else { System.out.println(“Queue is empty”);
nItems--; else {
return queArray[front++];
int temp = queArray[front++];
} if (front == maxSize)
} front = 0;
nItems--;
return temp;

}
}

23
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Question 05

Implement isFull(), isEmpty() and peekFront() methods of the

Circular Queue class.

24
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Question 06
Creating a Queue

Using the implemented QueueX class, Write a program to create a queue with
maximum size 10 and insert the following items to the queue.

10 25 55 65 85

Delete all the items from the queue and display the deleted items.

25
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

Creating a Queue
class QueueApp {
public static void main(String[] args) {
QueueX theQueue = new QueueX(10); // create a queue with max size 10

theQueue. insert(10); // insert given items

theQueue. insert(25);
theQueue. insert(55);
theQueue. insert(65);
theQueue. insert(85);

while( !theQueue.isEmpty() ) { // until it is empty, delete item from queue

int val = theQueue.remove();

System.out.print(val);
System.out.print(“ “);
}
}
} // end of class

26
Module Code | Module Name | Lecture Title | Lecturer
Data Structures and Algorithms

References

1. Mitchell Waite,Robert Lafore, Data Structures and

Algorithms in Java,2nd Edition, Waite Group Press,1998.

27
Module Code | Module Name | Lecture Title | Lecturer