Every data structure, no matter how simple or complex, is ultimately judged by what you can do with it and how much that costs. For lists and arrays, four operations form the core vocabulary: accessing an element at a given position, searching for an element by value, inserting a new element, and deleting an existing one. This topic asks you to describe each of these precisely — what steps the machine actually performs — before attaching any complexity notation to them.
The critical insight in this topic is that cost depends on position. Accessing the fifth element of an array is not the same work as accessing the fifth element of a singly linked list; inserting at the front of an array is not the same work as inserting at the end. Once you can articulate why shifting elements, traversing pointers, or indexing directly differ in effort, Big O notation becomes a natural shorthand rather than a memorized table.
The videos below extend the same operation vocabulary to other structures. As you watch, keep a running mental checklist: for each operation shown, ask where the work happens, whether the position of the operation changes the amount of work, and how the structure's layout makes some operations cheap and others expensive. That habit of questioning — not the specific structures demonstrated — is what carries into the rest of the course.
This lecture introduces the trie, a tree-based structure used for storing strings, and walks through how insertion, deletion, and searching are performed on it. Based on the title and description, you can expect a step-by-step treatment of each operation, likely with diagrams showing how characters are placed along paths from the root. It is part of a larger DSA course sequence, so it assumes some comfort with basic structures.
It demonstrates the same four-operation framework — insert, delete, search — applied to a structure very different from a flat array, which helps you see that these operations are a universal lens for analyzing any data structure rather than something specific to lists.
This Gate Smashers lecture introduces the stack and the two operations that define it, PUSH and POP, which are insertion and deletion restricted to a single end of the structure. Expect a clear explanation of how elements enter and leave, likely with worked examples of the top pointer moving as operations occur. The video is part of a widely used data structures lecture series aimed at exam and interview preparation.
Because a stack restricts insertion and deletion to one position, it is a clean illustration of the subtopic on how operation cost varies by position — it shows why limiting where operations can happen makes them cheap and predictable.
Both videos reinforce MO2 by presenting insertion, deletion, and search as the defining operations of a data structure and showing exactly what steps each requires. The stack lecture speaks directly to the idea that position determines cost, since restricting insertion and deletion to one end keeps those operations constant-time, which supports the reasoning behind MO3. The trie video widens your view by applying the same operation vocabulary to a structure with a very different layout, which supports MO1's emphasis on how structural characteristics shape behavior and prepares you for the trade-off reasoning required by MO4. Use both as practice in asking the central question of this module: for this structure and this position, how much work does the operation actually take?
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.