1. Queue

2. What is a queue? Queues have two ends:
It is an ordered group of homogeneous items, examples:
The cars at a stop light,
The check-out line at a grocery store
Queues have two ends:
Items are added at one end.
Items are removed from the other end.
FIFO property: First In, First Out
The item added first is also removed first

3. Conceptual View of a Queue
Adding an element
Front of queue
New element is added to the rear of the queue

4. Conceptual View of a Queue
Removing an element
New front element of queue
Element is removed from the front of the queue

5. Uses of Queues in Computing
For any kind of problem involving FIFO data
Printer queue Keyboard input buffer
GUI event queue (click on buttons, menu items)

6. Uses of Queues in Computing
In simulation studies, where the goal is to reduce waiting times:
Optimize the flow of traffic at a traffic light
Determine number of cashiers to have on duty at a grocery store at different times of day
Ticket counter simulation

7. Queue Operations enqueue : add an element to the tail of a queue
dequeue : remove an element from the head of a queue
front : examine the element at the head of the queue (“peek”)
Other useful operations (e.g. is the queue empty)
It is not legal to access the elements in the middle of the queue!

8. Array Implementation of a Queue
First Approach:
Use an array in which index 0 represents one end of the queue (the front)
Integer value last represents the last occupied slot in the array (the number of elements currently in the queue will be last + 1)
Discussion: What is the challenge with this approach?

9. Operations on a Queue Operation Description dequeue enqueue front
Removes an element from the front of the queue
enqueue
Adds an element to the rear of the queue
front
Examines the element at the front of the queue
isEmpty
Determines whether the queue is empty
size
Determines the number of elements in the queue
isFull
Determines whether the queue is full

10. An Array Implementation of a Queue
A queue aq containing four elements
first 1 2 3 4 …
queueArray aq 3
last

11. Queue After Adding an Element
last is incremented, Element is added at the array location given by the new last
first 1 2 3 4 …
queueArray aq 4
last

12. Queue After Removing an Element
Element is removed from array location 0, remaining elements are shifted forward one position in the array, and then last is decremented. 1 2 3 4 …
queueArray aq 3
last

13. Operations on a Queue Operation Description dequeue enqueue front
Removes an element from the front of the queue
enqueue
Adds an element to the rear of the queue
front
Examines the element at the front of the queue
isEmpty
Determines whether the queue is empty
size
Determines the number of elements in the queue
isFull
Determines whether the queue is full

14. Second Approach: Queue as a Circular Array
If we don't fix one end of the queue at index 0, we won't have to shift elements
Circular array is an array that conceptually loops around on itself
The last index is thought to “precede” index 0
In an array whose last index is n, the location “before” index 0 is index n; the location “after” index n is index 0
Need to keep track of where the first as well as the last of the queue are at any given time

15. Conceptual Example of a Circular Queue
first
After 5 dequeues 1 1
After 7 enqueues
first 12 12 11
last 11
last 10 10
last 1
first 12 11
After 8 more enqueues 10

16. Circular Array Implementation of a Queue3 2 3 4 1
first
queueArray 5 cq 7 5 6
n-1
last
currentsize
n-2 7
n-3 8 . 9 . 10 .

17. A Queue Straddling the End of a Circular Array98 2 3 4 1
first
queueArray 5 cq 1 4 6 99
last
currentSize 98 7 97 8 . 9 . 10 .

18. Circular Queue Drawn Linearly
Queue from previous slide 98 cq
first
queueArray 1 2 3 4 96 97 98 99 … 1 4
last
currentSize

19. Circular Array Implementation
When an element is enqueued, the value of last is incremented
But it must take into account the need to loop back to index 0:
last = (last+1) % queue’sLength;
Yes, so it may need enlarging

20. #ifndef INT_QUEUE_H_INCLUDED
#define INT_QUEUE_H_INCLUDED
class intQueue {
private:
int currentsize, arraysize, first, last;
int *queueArray;
public:
intQueue(int s = 100); // Constructor
~intQueue(); // Destructor
intQueue(const intQueue& other); // Copy Constructor
intQueue& operator=(const intQueue& other); // Assignment operator
bool enqueue(int); // Add to end
bool dequeue(); // Remove from front
int front() const; // Get value at front
bool isEmpty() const { return currentsize <= 0; }
bool isFull() const { return currentsize >= arraysize; }
int Size() const { return currentsize; } };
#endif // INT_QUEUE_H_INCLUDED

21. #include "intQueue.h"
#include <iostream>
#include <cstdlib>
using namespace std;
intQueue::intQueue(int s) // Constructor {
queueArray = new int[s]; // Dynamically allocate array
arraysize = s;
currentsize = 0;
first = 0;
last = -1; }
intQueue::~intQueue() // Destructor
delete[] queueArray; // Deallocate array

22. intQueue::intQueue(const intQueue& other) // Copy Constructor{
arraysize = other.arraysize;
currentsize = other.currentsize;
first = other.first;
last = other.last;
queueArray = new int[arraysize]; // Dynamically allocate array
for (int i=0; i<arraysize; i++) // Copy array contents
queueArray[i] = other.queueArray[i]; }
intQueue& intQueue::operator=(const intQueue& rhs)
if (this == &rhs) return *this; // handle self assignment
arraysize = rhs.arraysize;
currentsize = rhs.currentsize;
first = rhs.first;
last = rhs.last;
delete [] queueArray; // Deallocate old array
queueArray = new int[arraysize]; // Dynamically allocate new one
for (int i=0; i<arraysize; i++) // Copy array contents
queueArray[i] = rhs.queueArray[i];
return *this;

23. bool intQueue::enqueue(int value){
if (currentsize >= arraysize) return false;
last = (last + 1) % arraysize;
queueArray[last] = value;
currentsize++;
return true; }
bool intQueue::dequeue()
if (currentsize < 1) return false;
first = (first + 1) % arraysize;
currentsize--;
int intQueue::front() const
if (currentsize < 1)
cout << "Cannot take front of empty queue!\n";
exit(0);
return queueArray[first];