Queu

e
Queue Overview
◦Queue ADT
◦Basic operations of queue
◦ Enqueuing
◦ Dequeuing
◦Implementation of queue
◦ Array
◦ Linked list
Queue ADT
◦Like a stack, a queue is also a list.
◦Insertion is done only at one end,
while deletion is performed at the
other end.
◦Accessing the elements of queues
follows a First In, First Out (FIFO)
order.
◦Like customers standing in a check-out
line in a store, the first customer in is
The Queue ADT
◦Another form of restricted list
◦Insertion is done at one end,
whereas deletion is performed at the
other end
◦Basic operations:
◦enqueue: insert an element at the
rear of the list
◦dequeue: delete the element at the
front of the list
◦First-in First-out (FIFO) list
Remove Insert
(Dequeue) front rear (Enqueue)
Queue Implementation
using Array
◦There are several different
algorithms to implement Enqueue
and Dequeue
◦Naïve way
◦When enqueuing, the front index is
always fixed and rear
rear the rear index moves
rear
forward in the array.
3 3 6 3 6 9

front front front

Enqueue(3) Enqueue(6) Enqueue(9)
 Queue Implementation
using Array
◦Naïve way
◦ When enqueuing, the front index is always
fixed and the rear index moves forward in the
array.
◦ When dequeuing, the element at the front the
queue is removed. Move all the elements after
it by one position. (Inefficient!!!)
rear rear rear = -1

6 9 9

front front front

Dequeue() Dequeue() Dequeue()
 Queue Implementation
using Array
◦Better way
◦When an item is enqueued, make the
rear index move forward.
◦When an item is dequeued, the front
index moves by one element towards the
back of the queue (thus removing the
front item, so no copying to neighboring
(front elements is needed).
XXXXOOOOO (rear)
) OXXXXOOOO (after 1 dequeue, and 1 enqueue)
OOXXXXXOO (after another dequeue, and 2 enqueues)
OOOOXXXXX (after 2 more dequeues, and 2
enqueues)
The problem here is that the rear index cannot move
beyond the last element in the array.
 Queue Implementation
using Circular Array
◦Using a circular array
◦When an element moves past the
end of a circular array, it wraps
around to the beginning, e.g.
◦OOOOO7963 → 4OOOO7963 (after
Enqueue(4))
◦After Enqueue(4), the rear index moves
from 3 to 4.
 Issues with Queue
Implementation using
Circular Array
◦Empty queue
◦ back = front - 1
◦Full queue?
◦ back = front - 1 the same!
◦ Reason: n values to represent n+1 states
How to determine if the
circular Queue is Empty
or Full?
◦Solutions
◦ Use a Boolean variable to say explicitly
whether the queue is empty or not
◦ Make the array of size n+1 and only allow n
elements to be stored
◦ Use a counter of the number of elements in
the queue
 Queue Implementation
class Queue { using Arrays
public:
Queue(int size = 10); // constructor
~Queue() { delete [] values; } // destructor
bool IsEmpty(void);
bool IsFull(void);
bool Enqueue(double x);
bool Dequeue(double & x);
void DisplayQueue(void);
private:
int front; // front index
int rear; // rear index
int counter; // number of elements
int maxSize; // size of array queue
double* values; // element array
};
Queue Class
◦Attributes of Queue
◦front/rear: front/rear index
◦counter: number of elements in the
queue
◦maxSize: capacity of the queue
◦values: point to an array which
stores elements of the queue
Queue Class
◦Operations of Queue
◦IsEmpty: return true if queue is empty,
return false otherwise
◦IsFull: return true if queue is full,
return false otherwise
◦Enqueue: add an element to the rear of
queue
◦Dequeue: delete the element at the front
of queue
◦DisplayQueue: print all the data
 Creating Queue Class
◦Queue(int size = 10)
◦ Allocate a queue array of size. By default, size = 10.
◦ front is set to 0, pointing to the first element of the array
◦ rear is set to -1. The queue is empty initially.

Queue::Queue(int size /* = 10 */) {

values = new double[size];
maxSize = size;
front = 0;
rear = -1;
counter = 0;
}
IsEmpty & IsFull
◦Since we keep track of the number of elements
that are actually in the queue: counter, it is
easy to check if the queue is empty or full.

bool Queue::IsEmpty() {
if (counter) return false;
else return true;
}
bool Queue::IsFull()
if (counter < maxSize) return false;
else return true;
}
 Enqueue
bool Queue::Enqueue(double x) {
if (IsFull()) {
cout << "Error: the queue is full." << endl;
return false;
}
else {
// calculate the new rear position (circular)
rear = (rear + 1) % maxSize;
// insert new item
values[rear] = x;
// update counter
counter++;
return true;
}
}
 Dequeue
bool Queue::Dequeue(double & x) {
if (IsEmpty()) {
cout << "Error: the queue is
empty." << endl;
return false;
}
else {
// retrieve the front item
x = values[front];
// move front
front = (front + 1) %
maxSize;
// update counter
counter--;
return true;
}
Printing the
elements

void Queue::DisplayQueue() {
cout << "front -->";
for (int i = 0; i < counter; i++) {
if (i == 0) cout << "\t";
else cout << "\t\t";
cout << values[(front + i) % maxSize];
if (i != counter - 1)
cout << endl;
else
cout << "\t<-- rear" << endl;
}
}
 Sample run
using a
Queue
int main(void) {
Queue queue(5);
cout << "Enqueue 5 items." << endl;
for (int x = 0; x < 5; x++)
queue.Enqueue(x);
cout << "Now attempting to enqueue again..." << endl;
queue.Enqueue(5);
queue.DisplayQueue();
double value;
queue.Dequeue(value);
cout << "Retrieved element = " << value << endl;
queue.DisplayQueue();
queue.Enqueue(7);
queue.DisplayQueue();
return 0;
}
Queue Implementation
using Linked List
class Queue {
public:
Queue() { // constructor
front = rear = NULL;
counter = 0;
}
~Queue() { // destructor
double value;
while (!IsEmpty()) Dequeue(value);
}
bool IsEmpty() {
if (counter) return false;
else return true;
}
void Enqueue(double x);
bool Dequeue(double & x);
void DisplayQueue(void);
private:
Node* front; // pointer to front node
Node* rear; // pointer to last node
int counter; // number of elements
};
 Enqueue
void Queue::Enqueue(double x) {
Node* newNode = new Node;
newNode->data = x;
newNode->next = NULL;
if (IsEmpty()) {
front = newNode;
rear = newNode;
}
else {
rear->next = newNode;
rear = newNode; rear
}
counter++; 8 5
} rear

8 5
newNode
 Dequeue
bool Queue::Dequeue(double & x) {
if (IsEmpty()) {g
cout << "Error: the queue is empty." << endl;
return false;
}
else {
x = front->data;
Node* nextNode = front->next;
delete front;
front = nextNode;
counter--;
} front
}
3 8 5

front

8 5
 Printing the
elements
void Queue::DisplayQueue() {
cout << "front -->";
Node* currNode = front;
for (int i = 0; i < counter; i++) {
if (i == 0) cout << "\t";
else cout << "\t\t";
cout << currNode->data;
if (i != counter - 1)
cout << endl;
else
cout << "\t<-- rear" << endl;
currNode = currNode->next;

}
}
 Result
◦Queue implemented using linked list will
never be full

based on array based on linked list

END OF
SLIDES