A queue is an abstract data type that organizes elements in first-in, first-out (FIFO) order: items join at one end, called the rear or tail, and leave from the other end, called the front or head. What makes the queue useful is not a clever internal layout but the small, strictly defined set of operations it exposes. In this topic you study those operations one at a time — enqueue, dequeue, peek (front), and isEmpty — and learn exactly what each one does to the structure's state.
These operations matter because every later queue topic depends on them. When you implement a queue with an array or a linked list, you are really deciding how to make these four behaviors correct and efficient. Edge cases live here too: dequeueing or peeking an empty queue (underflow) and enqueueing into a full fixed-size array (overflow) are the conditions that separate working code from code that silently corrupts data.
As you watch, track two things. First, the front and rear indices or pointers: note precisely when each one moves, and what values they hold when the queue is empty versus holding one element. Second, the expected outcome of each operation — what is returned, what changes, and what error or condition is signaled when the operation cannot be performed.
This lecture walks through the primary queue operations, centering on enqueue() and dequeue() and touching on the other standard operations a queue supports. Based on the title and series, expect step-by-step tracing of how elements enter at the rear and leave from the front, with the front and rear markers updated as the queue changes. It establishes the vocabulary and expected behavior you will reuse in every queue implementation.
It is the direct match for the enqueue, dequeue, and peek subtopics, presented by Gate Smashers, a well-known exam-prep channel whose data structures lectures are widely used and consistently clear on operation mechanics.
This video focuses specifically on the status-checking operations of a queue: isEmpty() and isFull(). It explains the conditions on the front and rear values that signal an empty queue versus a full one, which is what guards a dequeue against underflow and an enqueue against overflow. Expect the boundary conditions to be stated as explicit tests you can write in code.
It covers the isEmpty subtopic head-on and supplies the precise edge-case conditions that determine the expected outcome of every other queue operation.
Here the operations are applied to a concrete array-based queue. The lecture covers how a queue is represented in an array and how enqueue() is implemented against that representation, including the index bookkeeping and the full-queue check. It connects the abstract operation definitions to actual code and memory layout.
It shows the operations in practice rather than in the abstract, which reinforces how each operation's expected behavior constrains an implementation — useful preparation for writing your own queue.
Together these videos build the operational foundation the module outcomes rest on. The first lecture ties enqueue and dequeue to FIFO ordering and the movement of front and rear, supporting MO1 and giving you the access-pattern vocabulary needed later to contrast queues with stacks (MO4, MO5). The isEmpty/isFull lecture supplies the edge-case conditions that MO2 requires you to handle correctly in code, and the array implementation video shows those operations realized in a concrete structure, which is the starting point for comparing array-based and linked list-based designs and their complexity trade-offs (MO2, MO3).
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.