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.
A queue is one of the simplest data structures to describe and one of the easiest to misuse if you do not take its ordering rule seriously. That rule is FIFO: First-In, First-Out. The first element placed into the queue is the first element taken out, and no operation is allowed to violate that order. Insertion happens at one end (the rear, via enqueue) and removal happens at the other (the front, via dequeue), which is what keeps the ordering honest.
FIFO matters in this course for two reasons. First, it is a defining constraint, not a convenience: the queue is interesting precisely because it refuses to let you reach into the middle. That restriction is what makes it predictable and what makes it the right tool for scheduling, buffering, print spooling, breadth-first traversal, and any situation where arrival order should determine service order. Second, FIFO becomes much clearer when you set it beside LIFO, the stack's ordering rule, where insertion and removal share a single end.
While watching, pay attention to three things: where elements enter and where they leave, how the front and rear positions move as operations occur, and how the stack's single point of access produces reversed output compared to the queue's preserved order. If you can predict the exact sequence of outputs for a given sequence of operations on both structures, you understand the principle.
This lecture introduces the queue as an abstract data type and grounds it in a real-life analogy, which is the standard way of making the FIFO rule intuitive. Expect coverage of the basic structure of a queue, the roles of the front and rear ends, and how insertion and removal operations follow First-In, First-Out ordering. It serves as the foundational overview for the module.
Gate Smashers produces exam-oriented computer science lectures with a reputation for clear, step-by-step explanations, and this video directly addresses what FIFO means and how insertion and removal work under it — the core of this topic.
This lecture introduces the stack and its two fundamental operations, PUSH and POP, explaining how both occur at a single end of the structure. It is likely to walk through how elements accumulate and are removed in reverse order of insertion, which is the LIFO principle. Although the subject is the stack, it provides the contrast you need to understand the queue.
Understanding FIFO is sharpest by comparison, and this companion lecture from the same instructor supplies the LIFO side of the contrast with consistent terminology and presentation style, supporting the FIFO-versus-LIFO subtopic directly.
Together these two videos cover the conceptual half of the module. The queue introduction supports MO1 by defining FIFO and showing how it governs enqueue and dequeue at opposite ends of the structure, and it begins the work of MO5 by connecting the ordering rule to realistic scenarios where arrival order should determine service order. The stack lecture supports MO4 by supplying the LIFO contrast — a single point of access producing reversed output — so you can articulate precisely how the two structures differ in ordering and access. Note that implementation details and complexity trade-offs (MO2 and MO3) are addressed elsewhere in the module; your goal here is to be fluent in the ordering principle before you write any code.
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.
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.
A queue is an abstract data type defined by its behavior: elements enter at the rear and leave from the front, in first-in-first-out order. Knowing that behavior is not the same as being able to build it. In this topic you move from the concept to the code, implementing the queue two different ways — on top of a fixed-size array and on top of a linked list — and seeing exactly what each choice costs you.
The array-based version is usually the first one students write, and it is also the one that exposes the most interesting problems. Where do front and rear pointers start? What happens when rear reaches the end of the array but space has been freed at the front? How do you distinguish an empty queue from a full one? The linked list version avoids the fixed-capacity problem but introduces pointer bookkeeping of its own, especially when the queue becomes empty and both head and tail must be reset.
As you watch, keep a running list of three things: the exact conditions that signal overflow and underflow, the pointer updates performed by enqueue and dequeue, and the time and space cost of each operation. You should finish this topic able to argue for one implementation over the other given a specific scenario, not just recite that both are O(1) for the core operations.
This lecture walks through building a queue on top of an array, focusing on the enqueue operation and the front and rear index variables that track the queue's boundaries. Based on its title and placement in a sequenced data structures series, it is likely to cover the initial values of the pointers, the overflow condition when rear reaches the end of the array, and the step-by-step code for inserting an element.
Gate Smashers produces exam-oriented data structures lectures with careful step-by-step tracing, which makes it a strong fit for the array-based implementation and edge-case handling subtopics where small index errors matter most.
The follow-up lecture in the same series implements the queue using a linked list, with enqueue highlighted in the title. Expect coverage of node creation, maintaining front and rear pointers, the special case of inserting into an empty queue, and how dynamic allocation removes the fixed-capacity limit of the array version.
Watching this immediately after the array lecture gives you the same instructor, notation, and worked style applied to the second implementation, which makes the structural trade-offs between the two approaches easier to see directly.
Geekific explains the queue ADT and then implements it both ways in Java, so array-based and linked-list-based versions appear side by side in a single video. The description points to an accompanying GitHub repository, so the full source for the core operations is available to read and run alongside the explanation.
Its dual-implementation format directly serves the trade-offs subtopic, and seeing real compilable Java code bridges the gap between the pseudocode in the lectures and the code you will write for this course.
Together these videos carry you from the FIFO definition into working code (MO1, MO2): the first two lectures build the array-based and linked list-based queues separately, with explicit attention to pointer initialization, overflow and underflow conditions, and the empty-queue edge case, while the Geekific video shows both implementations in compilable Java you can study and extend. Presenting the two approaches in parallel also sets up the comparison required by MO3, since you can weigh fixed capacity and index arithmetic against per-node memory overhead and pointer maintenance while both implementations are fresh. The implementation-level detail here reinforces the access-point reasoning — insert at rear, remove at front — that you will contrast with stack behavior when addressing MO4 and MO5.
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.
A queue is more than a classroom exercise in enqueue and dequeue. Nearly every system you interact with daily relies on something arriving first being served first: jobs waiting for a CPU, documents waiting for a printer, packets waiting for a network card, customers waiting for a support agent. In this topic we take the FIFO principle you learned abstractly and trace it through real systems so you can recognize a queue when you meet one in the wild.
The subtopics each highlight a different reason FIFO is the right fit. Task scheduling uses it for fairness and predictable wait times. Print spooling and data buffering use it to decouple a fast producer from a slow consumer. Message queues in distributed systems use it so that services can hand off work reliably without being online at the same moment. Breadth-first search uses it to explore a graph level by level, which is a purely algorithmic use with no waiting line in sight. Customer service and ticketing systems use it because people expect order of arrival to be respected.
As you watch the videos below, keep two questions in mind. First, what would break if the ordering guarantee were removed — would the result merely be unfair, or would it be wrong? Second, where is the queue actually stored, and who is producing and who is consuming? Being able to answer those two questions is what separates memorizing FIFO from being able to choose a queue for a problem you have never seen before.
Revisit this lecture after the other two if the applied examples raised questions about the underlying mechanics. The explanation of how front and rear move during enqueue and dequeue is what underpins every scheduling, spooling, and buffering example in this topic.
Grounding the applied material back in the core operations keeps the real-world discussion anchored to the abstract data type the module is actually assessing.
A lecture that treats stacks and queues together and moves past basic operations into applied uses, including how stacks manage function calls and recursion, and extending to graph work such as Dijkstra's algorithm in Java. The side-by-side treatment makes the contrast between LIFO and FIFO concrete rather than definitional. Expect code-level discussion rather than pure theory.
It supports the algorithmic end of this topic — the queue as a traversal engine in BFS and related graph algorithms — while the stack comparison helps you justify which structure fits a given access pattern.
A short, focused comparison of Amazon SQS Standard queues and SQS FIFO queues, walking through the architectural differences between the two. It covers what a managed message queue service actually guarantees about ordering and delivery, and where each queue type is appropriate. This is a production cloud service, not a textbook structure.
This is the clearest link to the message queues in distributed systems subtopic, and it shows that strict FIFO ordering is a deliberate design choice with trade-offs — a point that sharpens your understanding of why the guarantee matters.
Together these videos reinforce MO1 by repeatedly showing the FIFO principle governing enqueue and dequeue, first through everyday analogies and then through a cloud service that sells ordering as a feature. The stacks-and-queues lecture directly serves MO4 and MO5 by contrasting LIFO and FIFO access patterns in code and by demonstrating queue use inside graph algorithms, giving you concrete scenarios to justify a structure choice. The SQS comparison extends MO5 to a systems-level decision. Note that MO2 and MO3 — writing array-based and linked-list-based implementations and comparing their complexity — are addressed in the implementation materials elsewhere in this module rather than in these application-focused videos.
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.
Queues and stacks are both linear structures that restrict where you may insert and remove elements, but they restrict them in opposite ways. A queue follows FIFO (first in, first out): items enter at the rear and leave from the front, so the element that has waited longest is served first. A stack follows LIFO (last in, first out): items are pushed and popped at a single end, so the most recently added element is removed first. That single difference in the point of access is what drives everything else about how the two structures behave.
This comparison matters because in practice you rarely choose a structure by its name; you choose it by the ordering behavior a problem demands. Scheduling, buffering, breadth-first traversal, and any "serve in arrival order" situation point toward a queue. Undo histories, expression evaluation, backtracking, recursion and call stacks, and depth-first traversal point toward a stack. Being able to justify that choice is as important in this course as being able to code either structure.
As you watch the videos below, pay attention to three things: the vocabulary of the operations (push/pop versus enqueue/dequeue), where the pointers or indices live (top versus front and rear), and the real-world examples used to motivate each structure. The third video goes a step further and shows that the two structures are related closely enough that one can be simulated with the other — a useful way to confirm that you really understand what each ordering principle costs you.
An introductory lecture on the stack abstract data type, covering the LIFO ordering principle and the two core operations, PUSH and POP. Based on its title and description, it should walk through how the top pointer moves as elements are added and removed, and likely touches on overflow and underflow conditions. It is the stack half of the comparison you are building.
Gate Smashers lectures are widely used exam-prep material known for clear, step-by-step explanations, and this one gives you the precise stack terminology and single point of access you need to contrast against the queue.
An introduction to the queue data structure that, as the title indicates, motivates it with a real-life example. Expect coverage of the FIFO ordering principle, the front and rear ends, and the enqueue and dequeue operations that act on them. It pairs directly with the stack lecture from the same channel.
Using the same instructor and format as the stack video makes the side-by-side comparison of ordering principles, operations, and points of access very easy to see, and the real-life example supports the "when would I use this" subtopics.
A short, focused Geekific video on the classic problem of implementing a queue using two stacks, with visualization and code. It should show how pushing onto one stack and transferring to a second reverses the order, converting LIFO behavior into FIFO behavior, and discuss the cost of that transfer.
This is the best possible test of whether you truly understand the difference between the two orderings, and it reinforces the idea that ordering behavior — not the container — is what you are really selecting when you choose a structure.
Together these videos target the comparison outcomes of the module. The queue lecture reinforces the FIFO principle and the enqueue/dequeue operations that define it (MO1), while the stack lecture supplies the LIFO counterpart with its push/pop operations and single top-of-stack access point; watched together they give you the direct contrast in ordering principles, points of access, and typical use cases called for by MO4. The implement-a-queue-using-stacks video deepens that contrast by forcing you to reason about what it costs to convert one ordering into the other, which is exactly the kind of reasoning MO5 asks for when justifying a structure choice for a given problem. These videos support, but do not replace, the module's coverage of array-based and linked-list queue implementations 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.