Introduction to Queues

A queue is a fundamental data structure that follows the FIFO (First-In-First-Out) principle. Just like how people wait in a queue for their turn, a queue data structure works similarly. It is used to store a collection of elements in a linear order where the addition of new elements happens at one end and the removal of elements occurs at the other end.

In a queue, new elements are always added to the rear end of the queue, and existing elements are always removed from the front end of the queue.

Queues have several real-life applications. For example, an operating system uses a queue to manage processes that are waiting to be executed. Printers use queues to manage print spooling, ensuring that print jobs are handled in the order they are received.

To implement a queue, we can use an array or a linked list. In this lesson, we will focus on implementing a queue using an array.

Let's take a look at the C++ implementation of a queue using an array:

1#include <iostream>
2using namespace std;
3
4// Queue implementation using an array
5
6class Queue {
7private:
8    int front; // front pointer
9    int rear; // rear pointer
10    int capacity; // capacity of the queue
11    int* queue; // dynamic array to store the elements
12
13public:
14    Queue(int size) {
15        capacity = size;
16        front = 0;
17        rear = -1;
18        queue = new int[capacity];
19    }
20
21    // Other member functions
22    // ...
23};

In the above implementation, we have defined a Queue class that uses an array to store the elements. The class has private member variables front, rear, capacity, and queue. The front variable points to the front element of the queue, the rear variable points to the rear element of the queue, the capacity variable represents the maximum number of elements the queue can hold, and the queue variable is a dynamic array to store the elements.

The implementation also includes member functions for basic queue operations such as is_empty() to check if the queue is empty, is_full() to check if the queue is full, and enqueue() and dequeue() to add and remove elements respectively.

Feel free to modify the code and experiment with different operations on the queue to get a better understanding of how it works.

xxxxxxxxxx

}

#include <iostream>

using namespace std;

​

// Queue implementation using an array

​

class Queue {

private:

    int front; // front pointer

    int rear; // rear pointer

    int capacity; // capacity of the queue

    int* queue; // dynamic array to store the elements

​

public:

    Queue(int size) {

        capacity = size;

        front = 0;

        rear = -1;

        queue = new int[capacity];

    }

​

    bool is_empty() {

        return (rear == -1);

    }

​

    bool is_full() {

        return (rear == capacity - 1);

    }

​

    void enqueue(int value) {