An Introduction to Queues With Examples in C++

Size: px

Start display at page:

Download "An Introduction to Queues With Examples in C++"

Ross Preston
6 years ago
Views:

1 An Introduction to Queues With Examples in C++ Prof. David Bernstein James Madison University Computer Science Department Motivation Queues are very straightforward but are slightly more complicated than stacks Queues can be implemented in a number of different ways using the same data structure (i.e., with different algorithms) So, they are a good ADT to consider next An Analogy: A Waiting Line When you add a person to the line they go to the back People are served from the front (first-in-first-out or FIFO) A Definition of a Queue Queue Values: Operations: Homogeneous elements of any type. Name/Operator Arguments Returns Constructor A new instance. enqueue/append element The element to add to the rear of the queue dequeue/serve The element at the front of the queue isempty true if the queue is empty and false o/w

2 In addition, if the stack has a "size limit", one could add an isfull() operation; some people add a peek() operation; and some people add a makeempty() operation. An Array Implementation with Constant Shuffling Enqueue/append to the rear Dequeue/serve from the front (index 0) "Shuffle" after each serve An Analogy: A normal waiting line Constant Shuffling (cont.) cppexamples/arrayqueue/shuffling/queue.h #ifndef QUEUE_H #define QUEUE_H const int maxqueue = 10; class Queue public: / Default constructor Queue(); / Remove and return an element from the front of the The front element int dequeue(void); / Append an element onto the end of the item The element to append

3 void enqueue(int item); / Is this Queue true if the queue is empty and false otherwise bool isempty(void); private: int count; ; // The array containing the items int entry[maxqueue]; #endif cppexamples/arrayqueue/shuffling/queue.cpp #include "Queue.h" / Queue A queue (FIFO list) class Notes: This implementation uses an array and "shuffles" the entries every time an element is served / Default constructor

4 Queue::Queue() count = 0; / Remove and return an element from the front of the The front element int Queue::dequeue(void) int i, item; if (count <= 0) item = -1; else item = entry[0]; count--; for (i=0; i < count; i++) entry[i] = entry[i+1]; return item;

5 / Append an element onto the end of the item The element to append void Queue::enqueue(int item) if (count < maxqueue) entry[count] = item; count++; / Is this Queue true if the queue is empty and false otherwise bool Queue::isEmpty(void) bool result; if (count == 0) result = true; else result = false; return result; An Array Implementation with Periodic Moving Keep a "pointer" to the front and rear elements Move all of the elements down when space at the back runs out

6 One Analogy: A waiting line in which the server moves (until space runs out) Another Analogy: A clock in which the ticks are on a line, not a circle Periodic Moving (cont.) cppexamples/arrayqueue/moving/queue.h #ifndef QUEUE_H #define QUEUE_H const int maxqueue = 10; class Queue public: / Default constructor Queue(); / Remove and return an element from the front of the The front element int dequeue(void); / Append an element onto the end of the item The element to append void enqueue(int item); / Is this Queue empty?

7 @return true if the queue is empty and false otherwise bool isempty(void); private: int count, front, rear; ; // The array containing the items int entry[maxqueue]; #endif cppexamples/arrayqueue/moving/queue.cpp #include "Queue.h" / Queue A queue (FIFO list) class Notes: This implementation uses an array and a front and rear pointer. When the rear pointer reaches the maximum value, the contents are moved down (if space permits) / Default constructor Queue::Queue() rear = 0;

8 front = 0; count = 0; // What do you think about this? / Remove and return an element from the front of the The front element int Queue::dequeue(void) int item; if (count <= 0) item = -1; else item = entry[front]; count--; front++; return item; /

9 Append an element onto the end of the item The element to append void Queue::enqueue(int item) int i; if (count < maxqueue) entry[rear] = item; count++; rear++; if ((rear == maxqueue) && (front > 0)) for (i=0; i < count; i++) entry[i] = entry[front+i]; front = 0; rear = count; / Is this Queue true if the queue is empty and false otherwise bool Queue::isEmpty(void) bool result; if (count == 0) result = true; else result = false;

10 return result; A Circular Array Implementation Keep a "pointer" to the front and rear elements Have the "pointers" wrap around An Analogy: A circular waiting line in which the server moves Circular Implementation (cont.) cppexamples/arrayqueue/circular/queue.h #ifndef QUEUE_H #define QUEUE_H const int maxqueue = 10; class Queue public: / Default constructor Queue(); / Remove and return an element from the front of the The front element int dequeue(void);

11 / Append an element onto the end of the item The element to append void enqueue(int item); / Is this Queue true if the queue is empty and false otherwise bool isempty(void); private: int count, front, rear; ; // The array containing the items int entry[maxqueue]; #endif cppexamples/arrayqueue/circular/queue.cpp #include "Queue.h" / Queue A queue (FIFO list) class Notes: This implementation uses a "circular array"

12 / Default constructor Queue::Queue() rear = maxqueue - 1; front = 0; count = 0; // What do you think about this? / Remove and return an element from the front of the The front element int Queue::dequeue(void) int item; if (count <= 0) item = -1; else item = entry[front]; count--; front = ((front+1) == maxqueue)? 0 : (front+1); return item;

13 / Append an element onto the end of the item The element to append void Queue::enqueue(int item) if (count < maxqueue) count++; rear = ((rear + 1) == maxqueue)? 0 : (rear+1); // Another way: // // if ((rear+1) == maxqueue) rear = 0; // else rear++; // // A third way: // // rear = ((rear + 1) % maxqueue); entry[rear] = item; / Is this Queue true if the queue is empty and false otherwise bool Queue::isEmpty(void) return (count == 0); // Understand?

Chapter 18: Stacks And Queues

Chapter 18: Stacks And Queues 18.1 Introduction to the Stack ADT Introduction to the Stack ADT Stack a LIFO (last in, first out) data structure Examples plates in a cafeteria return addresses for function