Search⌘ K
AI Features
Home
Courses
Learn Data Structures and Algorithms

Key Operations of a Queue

Explore the fundamental operations of a queue data structure, including enqueue, dequeue, peek, isEmpty, and isFull. Learn how to implement these efficiently in Python using arrays or linked lists and understand their constant time complexities for practical problem-solving.

We'll cover the following...

Now that we understand how queues are implemented using arrays and linked lists, let's explore the fundamental operations for interacting with a queue. These operations define what makes a queue useful and how we manipulate the data it holds.

A queue supports several core operations, but they all revolve around the FIFO (First in, first out) principle. Before we can add or remove elements, we often need to check the queue's current state. Let’s begin with two essential utility operations.

The isEmpty operation

The isEmpty operation checks whether the queue contains any elements. This is crucial before attempting to remove or view elements, as attempting to dequeue from an empty queue results in an error.

Example: Consider a queue that currently holds the elements [88, 95, 72, 80, 91]. If we call isEmpty() on this queue, it would return False because the queue’s size is 5, not 0.

If we were to dequeue all five elements one by one, size would eventually become 0 again. At that point, calling isEmpty() would return True.

Python implementation

In an array-based queue, we can check if the queue is empty by comparing the size counter with 0. If size is equal to 0, no elements are present in the queue.

C++
class Queue:
    def __init__(self, capacity=10):
        self.capacity = capacity  # Maximum size of the queue
        self.data = [None] * capacity  # Array to store elements
        self.front = 0  # Index of the front element
        self.rear = -1  # Index of the rear element
        self.size = 0  # Number of elements currently in the queue
    
    def isEmpty(self):
        """Check if the queue is empty"""
        return self.size == 0
# Create an empty queue
queue = Queue(10)
print("Is queue empty?", queue.isEmpty())  # Output: True (queue is empty)

The isFull operation

The isFull operation checks whether the queue has reached its maximum capacity. This is only relevant for array-based queues with a fixed size, as in linked lists, we can add as many elements as we want until the system's memory runs out.

Example: Consider a queue with capacity 5 that currently holds [88, 95, 72, 80, 91]. If we call the isFull() function, it would return True.

If we dequeue one element (88), size would become 4. Now size (4) is less than capacity (5), so calling isFull() would return False.

Python implementation

In an array-based queue, we check if size equals capacity. If they match, the queue has no room for additional elements.

C++
class Queue:
    def __init__(self, capacity=10):
        self.capacity = capacity  # Maximum size of the queue
        self.data = [None] * capacity  # Array to store elements
        self.front = 0  # Index of the front element
        self.rear = -1  # Index of the rear element
        self.size = 0  # Number of elements currently in the queue
    
    def isEmpty(self):
        """Check if the queue is empty"""
        return self.size == 0
    
    def isFull(self):
        """Check if the queue is full"""
        return self.size == self.capacity
# Create a queue with capacity 5
queue = Queue(5)
# Simulate enqueuing 5 elements: [88, 95, 72, 80, 91]
queue.data[0] = 88
queue.data[1] = 95
queue.data[2] = 72
queue.data[3] = 80
queue.data[4] = 91
queue.front = 0
queue.rear = 4
queue.size = 5  # Set size to 5 (full)
print("Is queue full?", queue.isFull())  # Output: True (queue is full, size=5, capacity=5)

Enqueue operation

The enqueue operation adds a new element to the rear of the queue. This is how we insert data into the ...