Queue Data Structure

What is queue?
◼ A queue is a linier data structure.
The concept is quite similar with
stack.
◼ additions are made at the end or tail
of the queue while removals are
made from the front or head of the
queue.
◼ Access system a queue is referred to
a FIFO structure (First-In First-Out)
Queue operations
◼ Add : adds a new node
Add(X,Q) → add the value X to the tail of queue
◼ Remove : removes a node
Remove(Q) → removes the head node and returns
its value
◼ IsEmpty : reports whether the queue is
empty
IsEmpty(Q) → report whether the queue Q is empty
◼ IsFull : reports whether the queue is
full
IsFull(Q) → report whether the queue Q is full
◼ Initialize : creates/initializes the queue
Initialize(Q) → create a new empty queue named Q
◼ Destroy : deletes the contents of the
queue (may be implemented by re-
initializing the queue)
Destroy(Q) → deletes the contents of the queue Q
 Illustration/example
Operation Queue’s contents Return value

1. Initialiaze(S) <empty> -
2. Add(A,Q) A -
3. Add(B,Q) A B -
4. Add(C,Q) A B C -
5. Remove(Q) B C A
6. Add(D,Q) B C D -
7. Remove(Q) C D B
8. Remove(Q) D C
9. Remove(Q) <empty> D
Exercise: Queue Operation
What would the contents of a queue be
after the following operations?
Initialise(Q)
Add(A,Q)
Add(F,Q)
Add(X,Q)
Remove(Q)
Add(B,Q)
Remove(Q)
Remove(Q)
→B
Storing a queue in a static data
structure
◼ This implementation stores the queue in an array.
◼ The array indices at which the head and tail of the
queue are currently stored must be maintained.
◼ The head of the queue is not necessarily at index 0.
The array can be a “circular array” – the queue “wraps
round” if the last index of the array is reached.
Example – storing a queue in an array of length 5
Storing a queue in a static data
structure (2)

Continue the above example to show the state of the queue

after the following operations:
Add(E,Q)
Remove(Q)
Add(W,Q)
Add(J,Q)
Add(K,Q)

What happens at the last of these steps?

Storing a queue in a dynamic data
structure
◼ Each node in a dynamic data structure contains data
AND a reference to the next node.
◼ A queue also needs a reference to the head node AND
a reference to the tail node.
◼ The following diagram describes the storage of a
queue called Queue. Each node consists of data
(DataItem) and a reference (NextNode).

◼ The first node is accessed using the name Queue.Head.

◼ Its data is accessed using Queue.Head.DataItem
◼ The second node is accessed using
Queue.Head.NextNode
◼ The last node is accessed using Queue.Tail
Adding a node (Add) in a dynamic
data structure
The new node is to be added at the tail of the queue.
The reference Queue.Tail should point to the
new node, and the NextNode reference of the
node previously at the tail of the queue should
point to the DataItem of the new node.
Removing a node (Remove) in a
dynamic data structure
◼ The value of Queue.Head.DataItem is returned. A
temporary reference Temp is declared and set to point
to head node in the queue (Temp = Queue.Head).
◼ Queue.Head is then set to point to the second node
instead of the top node.
◼ The only reference to the original head node is now
Temp and the memory used by this node can then be
freed.
Queue Implementation
Queue Implementation in Java
◼ The Java Collections Framework
in the most recent version of
Java now includes queue
classes.
◼ As you did for the stack, you will
create your own Queue class in
order to learn how a queue is
implemented.
◼ Your class will again be a bit
simpler than the Collections
Framework one but it will do
essentially the same job
The Queue Class
◼ Since you implemented your stack as a static
structure, you will learn how to implement a
dynamic structure for your Queue

◼ The nodes of the queue will represented by instances of

a class Node. This holds a data item of type Object, and
a reference to the next Node. The data item can contain
any kind of Java object.
◼ The Queue class has references to two Nodes, the head
and the tail. The constructor sets these references to be
null as there are no Nodes initially.
◼ The Queue does not have a fixed size, so it will never be
full (unless the computer runs out of memory). The isFull
method simple returns false here.
The Queue Class (2)
Node.Java /* Constructor for objects of class Queue */
/* class Node.*/ public Queue()
public class Node {
{ // initialise head and tail references
head = null;
Object dataItem;
tail = null;
Node nextNode; }
}
/* sets all queue entries to null */
Queue.Java public void destroy()
/* class Queue */ {
Node temp = new Node();
public class Queue
Node setNull = new Node();
{ temp = head;
public Node head; while (temp!=null)
public Node tail; {
setNull = temp;
temp = temp.nextNode;
} setNull = null;
}
head = null;
tail = null;
}
 The Queue Class (3)
/* checks whether queue is empty*/ /* checks whether queue is full –
public boolean isEmpty() not properly implemented here */
{ public boolean isFull()
return head == null; {
} return false;
}

/* add an item to the queue */ /* remove an item by obeying FIFO

public void add(Object o) rule */
{ public Object remove()
Node newNode = new Node(); {
newNode.dataItem = o; if (head == null)
if (tail == null) return null;
{ else
head = newNode; {
tail = newNode; Node temp = new Node();
} temp = head;
else head = head.nextNode;
{ if (head == null) tail = null;
tail.nextNode = newNode; return temp.dataItem;
tail = newNode; }
} }
}
The Queue Class (4)
/* returns the number of items in the queue */
public int size()
{
int count = 0;
for (Node current=head;current!=null;
current=current.nextNode)
count++;
return count;
}
Using a Queue
◼ To use the Queue class, you need to know how to
write code to call the Queue operations, for example
to add data to the Queue.
◼ Remember that the Queue can hold any kind of
data. The following test class shows how to use a
/**
Queue to hold String objects.
/

/*class QueueTester. */
public class QueueTester
{
private Queue queue;
public QueueTester(){
queue = new Queue();
}
public QueueTester(Queue queue){
this.queue = queue;
}
void addString(String str)
void removeString()
} void checkIfEmpty()
void listStringsInQueue()
 Using a Queue (2)
/* check if queue is empty */
/* add item to queue */ public void checkIfEmpty() {
public void addString(String if (queue.isEmpty())
str) { System.out.println("Queue empty");
queue.add(str); else
System.out.println("Queue is not
System.out.println("Added empty");
new string"); }
}
/* list the strings in queue */
public void listStringsInQueue() {
/* remove item from queue */ if (queue.isEmpty()) {
public void removeString() { System.out.println("Queue
String result = (String) empty");
queue.remove(); }
else {
if (result!=null) System.out.println("Strings in
System.out.println("String is queue are: ");
:" + result); System.out.println();
Node node = queue.head;
else
while (node != null){
String item =
System.out.println("Remove (String)node.dataItem;
was unsuccessful"); System.out.println(item);
} node = node.nextNode;
}
System.out.println();
}
}
Exercise: Using a Queue
◼ Create a new BlueJ project called queues and create new
classes Node, Queue and QueueTester using the above
code.
◼ Create a new instance of Queue.
◼ Create a new instance of QueueTester and select your
Queue instance in the object bench as the parameter in the
constructor. This means that you will be testing the Queue
you created in the previous step.
◼ Call the checkIfEmpty method of your QueueTester.
What was the result?
◼ Call the addString method of your QueueTester to add the
string “The” to the queque.
◼ Repeat this to add the following strings: “queue”, “gets”,
“longer”
What result would you expect if you remove from the
Queue?
◼ Call the removeString method of your QueueTester and
check that you got the correct result.
◼ Call the add method of your QueueTester to add the strings
“every” and “day” to the queue.
What do you expect the contents of the Queue to be now?
◼ Inspect your Queue object. You should see references to the
head and tail of the Queue.
For Your EXERCISE:
Storing other types of data
◼ Modify the QueueTester class to
store Double objects in a Queue
instead of String objects, and test in
a similar way to the above.
◼ You should not have to change the
Queue class at all.
EXERCISE: A practical application
of the Queue class
◼ A queue is a useful data structure for holding data which
should be processed in the order it is created, but which
cannot always be processed straight away. A typical
application might be a messaging system. In the following
example, messages are received in the order they were
sent.
◼ The classes involved are Message, MessageSender and
MessageReceiver:
⚫ A Message object has a sender, a recipient, a content string
and a date.
⚫ A Message is placed in a Queue by a MessageSender
object.
⚫ A Message is removed from the queue by a
MessageReceiver object, which can also display the
contents of the Queue.
◼ The Queue class you have created in this chapter can
hold any type of object, including Messages, so you can
use it in this example as it is.
◼ Add the following classes to your queues project:
 EXERCISE: A practical application (the code)
Message.Java

import java.text.*;
import java.util.Date;
/** class Message */
public class Message
{
public String sender;
public String recipient;
public String content;
public Date date;

/**Constructors for objects of class Message */

public Message()
{
this.sender = "unknown sender";
this.recipient = "unknown recipient";
this.content = "none";
this.date = new Date();
}
public Message(String sender, String recipient, String content)
{
this.sender = sender;
this.recipient = recipient;
this.content = content;
this.date = new Date();
}

/**returns date/time at which message was created

* @return String - formatted representation of date */
public String getDate()
{
returnDateFormat.getDateTimeInstance().
format(this.date);
}
}
 EXERCISE: A practical application (the code)
MessageSender.Java

/**class MessageSender. */
public class MessageSender
{
/** places a message on a specified queue */
public void sendMessage(String sender, String recipient, String content, Queue q)
{
Message m = new Message(sender, recipient, content);
if(!q.isFull()){
q.add(m);
System.out.println("Message placed on queue");
}
else
System.out.println("Cannot send - queue is full");
}
}
 EXERCISE: A practical application (the code)
MessageReceiver.Java

/** class MessageReceiver */

public class MessageReceiver
{
/** receives and outputs a message from a specified queue */
public void receiveMessage(Queue q)
{
Message m = (Message) q.remove();
if (m != null)
{
System.out.println("Date: " + m.getDate());
System.out.println("From: " + m.sender);
System.out.println("To: " + m.recipient);
System.out.println("Content: " + m.content);
}
else
System.out.println("No messages to receive");
}
/** outputs contents of a queue */
public void showQueue(Queue q)
{
Message m;
System.out.println("Queue contains " + q.size() +
" messages");
if (q.isEmpty()) {
System.out.println("Queue empty");
}
else {
Node node = q.head;
while (node != null){
m = (Message)node.dataItem;
System.out.println(m.getDate() + ", From:" +
m.sender + ", To:" + m.recipient);
node = node.nextNode;
}
}
}
}
EXERCISE: A practical application of
the Queue class (test sequence)
◼ Create new instances of MessageSender, MessageReceiver and your
Queue class
◼ Use the MessageSender instance to add the following messages to the
queue:
Sender Recipient Content
Rudy Aini Assalamu’alaikum
Rida Ahmad What does the mean?
Hakiem Husein See you later
◼ Use the MessageReceiver instance to:
⚫ Display the queue contents
⚫ Remove the first message in the queue
⚫ Display the queue contents again
◼ Use appropriate methods to add the following messages to the Queue,
remove the first message and display the queue contents again.
Sender Recipient Content
Wildan Abdul Good Evening
Diana Fikri Bye for now
◼ Use appropriate methods to remove the first message and add the
following message to the Queue, and display the Queue contents again.
Sender Recipient Content
Rizki Adinda I love you