A queue is one of the most intuitive data structures you will meet in this course, because you already use one every time you wait in line. Formally, a queue is an ordered collection in which elements are added at one end, called the rear or tail, and removed from the other end, called the front or head. This single restriction produces the First-In, First-Out (FIFO) ordering principle: the element that has waited the longest is the next one to leave.
In COP3530 the queue matters for two reasons. First, it is a clean example of an abstract data type (ADT): the interface — enqueue, dequeue, peek, isEmpty — is defined by behavior, not by any particular implementation, and the same interface can be built on an array or on a linked list. Second, queues appear constantly inside larger algorithms and systems, from CPU and print scheduling to breadth-first search on graphs, so understanding them now pays off later in the course.
As you watch the videos below, keep three questions in mind. What exactly happens to the front and rear pointers during an enqueue and a dequeue? Which conditions count as edge cases (empty queue, full queue, a single remaining element)? And how does the queue's access pattern differ from a stack's, where insertion and removal happen at the same end? Being able to answer those questions in your own words is the goal of this topic.
This lecture introduces the queue data structure from scratch, using an everyday real-life analogy — the kind of waiting line you stand in — to motivate the FIFO rule. It covers the basic vocabulary of front and rear, the enqueue and dequeue operations, and where queues show up in computing. At roughly nine minutes it is the most leisurely of the three videos and spends time on conceptual grounding rather than code.
Gate Smashers is a widely followed exam-preparation channel known for clear, blackboard-style CS explanations, and the real-life framing makes this an ideal first exposure to the FIFO principle and core terminology before any implementation details appear.
A compact, three-minute overview of queues that moves quickly through the definition, the FIFO ordering, and the standard operations. The description links to a Python implementation on GitHub and cites Introduction to Algorithms, so expect a presentation grounded in standard textbook treatment. Use it as a fast summary or a review pass.
Michael Sambol's short algorithm videos are well regarded for accuracy and economy; this one gives you a precise, textbook-aligned statement of what a queue is, which complements the longer conceptual lecture.
This video explains the queue and then walks through implementing it in Java two different ways: with an array and with a linked list. Expect discussion of the operations in code, the structural differences between the two backing representations, and the practical details that come with each. A GitHub repository is linked for the accompanying source.
It bridges the gap between the queue as an abstract data type and the queue as working code, directly supporting the subtopic on ADTs and previewing the array versus linked list comparison that the rest of the module develops.
Together these videos build the conceptual foundation the module's outcomes depend on. The Gate Smashers lecture and the Sambol summary give you two independent statements of the FIFO principle and the enqueue/dequeue operations, which is exactly what MO1 asks you to define and explain. The Geekific video takes the next step by showing array-based and linked list-based implementations side by side, previewing the coding work in MO2 and giving you the concrete picture of each representation you will need when you reason about time and space trade-offs in MO3. Finally, by making the queue's single-direction access pattern explicit, all three videos set up the contrast with the stack that MO4 and MO5 require — once you can say precisely where a queue inserts and removes, deciding between a queue and a stack for a given scenario becomes a matter of matching the required ordering to the structure.
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.