queues

College of Computing & Information Technology
King Abdulaziz University
CPCS-204 – Data Structures I
Queues

Queues page 2
© Dr. Jonathan (Yahya) Cazalas
Queues – An Overview
 Queues:
 Like stacks, Queues are an Abstract Data Type
 They are NOT built into the core feature set of JAVA
 We must define them and their behaviors
 So what is a queue?
 A data structure that stores information in the form of a
typical waiting line
 New items are added at the end of the queue
 Elements are removed from the front of the queue
 So unlike a stack
 A queue is accessible from both ends (front and end)

Queues page 3
 Queues:
 Access Policy:
 The first element that is inserted into the queue is the first
element that will leave the queue
 Therefore, in order for the last element to leave the queue, it
must wait until all elements preceding it are removed
 Known as the “First in, First out” access policy
 FIFO for short
 Real life example: waiting in line to be served
 When a customer arrives, they enter the line at the back
 They wait their turn
 Finally, they get to the front, are served, and exit the line

Queues page 4
 Queues:
 Basic Operations:
 enqueue:
 Inserts and element at the end of the queue
 O(1) time
 dequeue:
 Removes the element at the front of the queue
 O(1) time
 peek:
 Looks at the element at the front of the queue without actually
removing it
 O(1) time

Queues page 5
 Queues:
 Basic Operations:
 isEmpty:
 Checks to see if the queue is empty
 O(1) time
 isFull:
 Checks to see if the queue is full
 O(1) time
 clear:
 Clears the contents of the queue
 In “queue” order
 From front to back
 O(n) time

Queues page 6
front
START: 2 4 6 8 10
Q
rear
Sequence of operations
Time Operation
1 enqueue(12)
2 dequeue
3 enqueue(14)
4 enqueue(16)
5 dequeue
time 1: 2 4 6 8 10 12
time 2: 4 6 8 10 12
time 3:
4 6 8 10 12 14
time 4: 4 6 8 10 12 14 16
time 5: 6 8 10 12 14 16
FIFO Nature of a Queue

Queues page 7
Queues: Implementation in JAVA
 Implementation of Queues in JAVA:
 As with Stacks, there are two obvious ways to
implement Queues :
1) Using arrays
2) Using linked lists
 We will go over both…

Queues page 8
 Array:
 We will implement the queue as an array!
 What does this mean?
 This means that when you examine the code for the queue, in
fact, it is simply using an array!
 So then how is the array a queue? What makes it a
queue?
 The BEHAVIOR!
 We said that an Abstract Data Type is defined based on
its behaviors (the operations it can perform).
 So we will restrict the behavior of the array.
 We will make the array behave like (act like) a queue!

Queues page 9
 Array:
 So we will restrict the behavior of the Queue.
 We will make the array behave like (act like) a queue!
 Example:
 With an array, you can insert anywhere or delete anywhere
 Insert at the beginning, middle, or end…anywhere!
 However:
 Since we are making this array behave like (act like) a queue:
 We will ONLY allow insertion at the “back”
 ENQUEUE
 We will ONLY allow deletion at the “front”
 DEQUEUE
 So now, our array has basically transformed into a queue!

Queues page 10
Queues: Array Implementation
 Queues:
 Array Implementation:
 How would you implement a queue using an array?
 Think of what “stuff” you would need…
 Other than the actual array, what else do you need?
 Remember, you need to enqueue and dequeue
 Meaning:
 You need to ALWAYS know where the front and back of the
queue are.

Queues page 11
 Queues:
 Here is our class, QueueArray:
class QueueArray {
private int[] queue;
private int front;
private int rear; // not actually needed
// Constructor and Methods here
}

Queues page 12
Time Operation
1 dequeue
2 enqueue(12)
3 dequeue
4 dequeue
5 dequeue
6 dequeue
7 dequeue
front
time 5:
rear
10 12
front
start: 2 4 6 8 10
Q
rear
front
time 1: 4 6 8 10
rear
front
time 3: 6 8 10 12
rear
front
time 4: 8 10 12
rear
Notice that the
array now has
room to add
elements to the
queue.
time 2:
front
4 6 8
rear
10 12
“brute force” method

Queues page 13
front
time 5:
rear
10 12
front
start: 2 4 6 8 10
Q
rear
front/rear
time 6: 12
front
time 7:
rear
Time Operation
1 dequeue
2 enqueue(12)
3 dequeue
4 dequeue
5 dequeue
6 dequeue
7 dequeue

Queues page 14
 Queues:
 What is wrong with the last example?
 enqueues run in O(1) time.
 This is a GOOD thing!
 But look at the dequeue
 How long does a dequeue take?
 The dequeue itself takes O(1) time
 However, after the first node is removed, ALL nodes, that
remain in the queue after the dequeue, must be moved
forward one position in the array
 Possibly n elements have to move after one dequeue
 This is O(n) time per deletion!
 And we know, conceptually, a dequeue should be O(1)

Queues page 15
Queues: Array Implementation (2)
 Queues:
 How can we do better?
 Well, we want to avoid moving all items when a
dequeue occurs
 But if we don’t move the individual elements…
 What must we do?
 We MUST move the front and back “pointers” to those
items
 An example makes this clear…

Queues page 16
front
time 5:
rear
10 12
front
time 2:
rear
4 6 8 10 12
front
start: 2 4 6 8 10
Q
rear
front
time 1: 4 6 8 10
rear
front
time 3: 6 8
rear
10 12
front
time 4: 8
rear
10 12
Notice that the
queue now
appears to be full
even though there
are locations
available in the
array!
Time Operation
1 dequeue
2 enqueue(12)
3 dequeue
4 dequeue
5 dequeue
6 dequeue
7 dequeue

Queues page 17
front
time 5:
rear
10 12
front
start: 2 4 6 8 10
Q
rear
time 6:
front/rear
12
front
time 7:
rear
Even Worse:
The queue now
appears full even
though there are
NO items in the
array!
Time Operation
1 dequeue
2 enqueue(12)
3 dequeue
4 dequeue
5 dequeue
6 dequeue
7 dequeue

Queues page 18
 Queues:
 What is wrong with the last example?
 The problem: we end up with wasted cells
 As the front moves towards the rear (when dequeues
occur), we have empty, useless cells in the array
 So we avoided the n moves when we dequeue
 We did so by simply moving the reference to front
 But in the process we have wasted space
 How can we do better?
 We view the array as if it were circular

Queues page 19
 Queues:
 Circular Array Implementation
 Circular arrays are a very common way of implementing
an array-based queue
 What is a circular array?
 It is a regular array
 We simply “view” it as being circular
 In a circular implementation, the queue is considered to
be full whenever the front of the queue immediately
precedes the rear of the queue in the counterclockwise
direction.
 The examples on the following pages should help you to
visualize a “circular” array.

Queues page 20
2 15 11 10 6 8
4
front rear
normal array implementation: queue is full
6 8 4 2 15 11
10
front
rear
circular array implementation: queue is full
15
2
4
8
6
10
11
rear front
visualization of a queue
implemented as a circular array

Queues page 21
 Queues:
 This implementation allows us to keep the elements in
their respective “cells” of the array
 We don’t need to move n elements during dequeues
 AND we also don’t have wasted space!
 The circular “view” of the array allows us to “wrap”
around the array
 Assume the length of the array is SIZE
 It is NOT the case that the rear most stop at index[SIZE-1]
 meaning, the last element
 Rather, since the array wraps around, the front could be at a
greater index than the index of the rear!

Queues page 22
Queues: Circular Array
Implementation
 Queues:
 The next several slides illustrate the operation of a
circular array based implementation of a queue.
 The normal implementation (brute-force) is also shown
for comparative purposes.
 However, remember that the brute force method is
extremely inefficient due to the amount of data
movement required by dequeue operations.

Queues page 23
Implementation
 Queues:
 The scenario begins at some point in time before which
other enqueue and dequeue operations have occurred
on the queue.
 Our scenario begins with some elements already in the
queue.
 As you can see on the next page, these elements were
enqueued in the order of: 2, 4, and 8.
 The scenario continues by enqueuing 6, enqueuing 10,
dequeue, enqueuing 18, dequeue, dequeue, dequeue,
enqueuing 9, dequeue, dequeue, and finally one last
dequeue which empties the queue at this point.

Queues page 24
after insertion of element 6
6
4
2
rear
front
8
Enqueue element 6
4 8
2
front rear
before
normal array implementation
4 8 6
2
front rear
after
2 4 8
front rear
before
circular array implementation
2 4 8 6
front rear
after
Implementation

Queues page 25
Enqueue element 10
4 8 6
2
front rear
before
4 8 6 10
2
front rear
after
2 4 8 6
front rear
before
2 4 8 6
10
front
rear
after
Implementation
6
4
2
rear
front
8
10

Queues page 26
dequeue
4 8 6 10
2
front rear
before
8 6 10
4
front rear
after
2 4 8 6
10
front
rear
before
4 8 6
10
front
rear
after
Implementation
after dequeue operation
6
4
rear
front
8
10

Queues page 27
Enqueue element 18
8 6 10
4
front rear
before
8 6 10 18
4
front rear
after
4 8 6
10
front
rear
before
18 4 8 6
10
front
rear
after
Implementation
6
4
rear
front
8
10
18

Queues page 28
dequeue
8 6 10 18
4
front rear
before
6 10 18
8
front rear
after
18 4 8 6
10
front
rear
before
18 8 6
10
front
rear
after
Implementation
6
rear
front
8
10
18

Queues page 29
dequeue
6 10 18
8
front rear
before
10 18
6
front rear
after
18 8 6
10
front
rear
before
18 6
10
front
rear
after
Implementation
6
rear
front
10
18

Queues page 30
dequeue
10 18
6
front rear
before
18
10
front rear
after
18 6
10
front
rear
before
18
10
front rear
after
Implementation
rear
front
10
18

Queues page 31
Enqueue element 9
18
10
front rear
before
18 9
10
front rear
after
18
10
front rear
before
18 9
10
front rear
after
Implementation
rear
front
10
18
9

Queues page 32
dequeue
18 9
10
front rear
before
9
18
front rear
after
18 9
10
front rear
before
18 9
front rear
after
Implementation
rear
front
18
9

Queues page 33
dequeue
9
18
front rear
before
9
front/rear
after
18 9
front rear
before
9
front/rear
after
Implementation
rear
front
9

Queues page 34
dequeue – queue empties!
9
front/rear
before
front/rear
after
9
front/rear
before
front/rear
after
Implementation
rear
front

Queues page 35
 Queues:
 So this works great in pictures
 But think about something…
 How did we modify the position (index) of front and rear?
 Did we just increment the front/rear indices as needed?
 Meaning, did we simply increment the index of rear every time
an enqueue occurs?
 And did we simply increment the index of front every time a
dequeue occurs?
 In a normal array, this is fine.
 However, this is a circular array, and we must pay attention!
 Simply incrementing will not cut it!
Implementation

Queues page 36
 Queues (Circular Array Implementation):
 Dequeue Operation
 How did we modify the position (index) of front and rear?
 Ex: suppose we have the situation below (also from page 34)
 If we dequeue, the front will need to refer to the ‘10’ in index 0!
 So how do we make this happen?
 Can we simply increment front?
 No, we cannot, as that would be out of bounds!
Implementation
18 6
10
front
rear
before

Queues page 37
 One possible solution: use an if/else statement
 If the front is currently equal to “queue.length – 1”
 Meaning, if the front is currently at the last index of the array
 And if we are performing a dequeue
 Then, the *new* front index will need to be set to index 0.
 Else, simply increment front.
 Of course, either way, we need to RETURN the value that was
at the front index (because this is a dequeue operation).
Implementation
18 6
10
front
rear
before

Queues page 38
 Here is the code:
Implementation
18 6
10
front
rear
before
public int dequeue() {
int temp = queue[front];
if (front == queue.length - 1)
front = 0; // set the new front to zero
else
front++; // just increment the front
// Finally, return the value that was at front
return temp;
}

Queues page 39
 The last solution does work…but it has a branch operation
 Meaning, it has an if/else statement.
 This is fine, but branching operations can be slow
 Instead of using an if/else statement to recalculate the position
of front, consider the following…
 front = (front + 1) % queue.length;
 So on our example, (6 + 1) % 7 = 0
 This is PRECISELY the index we want!
 The new front is calculated as index 0.
Implementation
18 6
10
front
rear
before
The ‘7’ here refers to
the size of the array

Queues page 40
 The last solution does work…but it has a branch operation
 Meaning, it has an if/else statement.
 So how do we get front to “point” to index 0?
 We need to use mod (%)!
 We increment front and then mod it by the queue size
 front = (front + 1) % queue.length;
 So now the new front refers to index 0.
 This is PRECISELY the index we wanted!
Implementation
18 6
10
front
rear
before

Queues page 41
 New Solution using mod (%):
 Here is the code:
Implementation
18 6
10
front
rear
before
public int dequeue() {
int temp = queue[front];
// Now update the location of front using mod
front = (front+1) % queue.length;
// decrement numItems (you will see why we use numItems)
numItems--;
// And finally, return temp...the value we dequeued
return temp;
}

Queues page 42
 Enqueue Operation
 We do NOT need to save the index for the rear.
 Why?
 Because if we know the index to the front
 AND if we know the number of elements
 we can quickly determine the new enqueue position
 Ex: let’s say front was at index 7 and there are 2 elements
 This means the rear would be at index 8
 And the NEW enqueue position would be index 9
 So we see that the NEW enqueue position is found by simply
adding the index of the front and the number of elements
 But we need to take care of wraparound…
Implementation

Queues page 43
 Assume we have a queue of size 10
 From index 0 to index 9
 The front is currently index 4
 And there are 6 elements already in the queue
 And the next operation is enqueue(g)
 Remember, enqueue is a method that we write in the program
 So this ‘g’ is sent over to the enqueue method as “char val”
Implementation
a b c
front
d f
e

Queues page 44
 From index 0 to index 9
 And there are 6 elements already in the queue
 We know that the next enqueue will go at index 0
 But how do we do this?
 One solution: if/else statement
Implementation
a b c
front
d f
e
g

Queues page 45
 numItems is currently 6 (values a to f)
 IF (front+numItems) equals the size of the array
 Meaning if (front+numItems == queue.length)
 This means that the NEW enqueue position must be at index 0!
 So we will save the new enqueue value at index 0.
 Else, just save the new enqueue value at the next position
available by incrementing
Implementation
a b c
front
d f
e
g

Queues page 46
 numItems is currently 6 (values a to f)
 Here is the code:
Implementation
a b c
front
d f
e
g
public void enqueue(int value) {
if ((front+numItems) == queue.length)
queue[0] = value;
else
queue[(front+numItems)] = value;
numItems++; // Finally, increment numItems
}

Queues page 47
 Again, the last solution does work…but it has a branch
 Which is a slow operation.
 Instead, we can again use mod (%).
 We know that the next enqueue will go at index 0
 But how do we do this in code (using mod)?
 queue[(front + numItems)%queue.length] = value;
 So for our example:
 queue[(4 + 6) % 10] = value;
 queue[0] = a … so the value ‘a’ get saved into index 0!
Implementation
a b c
front
d f
e
g

Queues page 48
 Again, the last solution does work…but it has a branch
 Which is a slow operation.
 Instead, we can again use mod (%).
 Here is the code:
Implementation
a b c
front
d f
e
g
public void enqueue(int value) {
queue[(front+numItems) % queue.length] = value;
numItems++;
}

Queues page 49
Brief Interlude: Summer in Saudi

Queues page 50
Queues: Linked-List Implementation
 Linked-List:
 We will implement the queue as a Linked-List!
 What does this mean?
 This means that when you examine the code for the queue, in
fact, it is simply using a Linked-List!
 So then how is the Linked-List a queue? What makes it a
queue?
 The BEHAVIOR!
 We said that an Abstract Data Type is defined based on
its behaviors (the operations it can perform).
 So we will restrict the behavior of the Linked-List.
 We will make the Linked-List behave like (act like) a queue!

Queues page 51
 Linked-List :
 So we will restrict the behavior of the Queue.
 We will make the Linked-List behave like (act like) a queue!
 Example:
 With a Linked-List, you can insert or delete anywhere
 Insert at the beginning, middle, or end…anywhere!
 However:
 Since we are making this Linked-List behave like a queue:
 We will ONLY allow insertion at the “back”
 ENQUEUE
 We will ONLY allow deletion at the “front”
 DEQUEUE
 So now, our Linked-List has transformed into a queue!

Queues page 52
 Queues:
 Linked-list implementation
 Think of how this will work.
 You need to know where is the front and where is the
back.
 So where do you want the front of the queue to be?
 Do you want it to be the head of the list?
 Or do you want it to be the tail/rear of the list?
 The choice is yours!
 Let us make the front of the queue as the head of the list.
 And the rear will simply be the location of the last node.

Queues page 53
 Queues:
 Dequeue:
 Remember, the front of the queue is the head of the list.
 Therefore, when we dequeue, this means we will simply
perform a delete command from the FRONT of the linked
list.
 This is very easy to do…we simply make front point to
front.next!
 front = front.getNext();
 There are a few other things to consider as well
 See the QueueLL.java code given on the website.

Queues page 54
 Queues:
 Enqueue:
 Now consider enqueue. How will you enqueue the next
item into the queue?
 Well, you need to know where is the current last item.
 One solution…traverse each time to the current last item.
 And then enqueue the new item afterwards.
 This would be very slow!
 Every time you want to enqueue, you would have to
traverse your entire list.
 What if the list was huuuuuuuge?

Queues page 55
 Queues:
 Enqueue:
 Better solution: used a tail/back pointer
 Meaning inside the QueueLL.java code, you will always
maintain (keep) a reference to the last node
 So this class will have two important variables:
 private QueueNode front;
 private QueueNode back;
 Both of these variables need to be updated whenever
enqueue and dequeue operations are performed
 See code on website for more details.

Queues page 56
 Linked Lists Implementation of Queues:
 Therefore:
 An enqueue is simply inserting into the back of the
linked list!
 This is very easy because we keep a pointer to the last node.
 It only requires changing two references!
 A dequeue would be deleting the front node
 Again, the easiest type of deletion
 Only requiring changing two references!
 So, in fact, a linked-list version of a queue is EASIER to
code than a regular linked list!

Queues page 57
 So each node will be an element of the queue
 Each node has a data value
 Each node also has a next
 We simply enqueue (insert at back)
 And dequeue (delete the front node)

Queues page 58
 So we will create two classes (like Linked-Lists)
 QueueNode.java (this is like the LLnode class)
 QueueLL.java (this is like the LinkedList class)
 We use most of the SAME methods as used for
the Linked List class
 However, we RESTRICT the functionality
 Now, we cannot insert anywhere in the list
 We can only insert at the back (enqueue)
 Now, we cannot delete from anywhere in the list
 We can only delete from the front (dequeue)

Queues page 59
 Code for QueueNode.java
public class QueueNode {
private int data;
private QueueNode next;
// CONSTRUCTORS
public QueueNode() {
data = 0;
next = null;
}
public QueueNode(int data) {
this.data = data;
next = null;
}
public QueueNode(int data, QueueNode next) {
this.data = data;
this.next = next;
}

Queues page 60
...
// ACCESSORS
public int getData() {
return data;
}
public QueueNode getNext() {
return next;
}
// MUTATORS
public void setData(int data) {
this.data = data;
}
public void setNext(QueueNode next) {
this.next = next;
}
}

Queues page 61
 Code for QueueLL.java (similar to LinkedList.java)
public class QueueLL {
// top: reference variable to the top of the stack
// (same as "head" of linked list)
private QueueNode front;
private QueueNode back;
// CONSTRUCTOR
public QueueLL() {
front = null;
back = null;
}
// MANY methods go here to control the stack
// POP, PUSH, TOP and more...

Queues page 62
 Code for QueueLL.java (similar to LinkedList.java)
 dequeue() method:
// QueueNode | dequeue()
public QueueNode dequeue() {
QueueNode temp = front;
front = dequeue(front);
if (front == null)
back = null;
return temp;
}
// QueueNode | dequeue(QueueNode)
private QueueNode dequeue(QueueNode front) {
front = front.getNext();
return front;
}

Queues page 63
Queues
WASN’T
THAT
SUPERB!

Queues page 64
Daily Demotivator

queues

More Related Content

Similar to queues

More from Mohamed Elsayed

Recently uploaded

queues