Big O notation becomes genuinely useful the moment you apply it to real operations on real structures. In this topic you take the four core operations you already know — access, search, insertion, and deletion — and attach a cost class to each one as it behaves on an array and on a linked list. Accessing an array element by index is O(1) because address arithmetic finds the slot directly, while searching an unsorted sequence is O(n) because, in the worst case, every element must be examined. Insertion and deletion are the interesting cases: the cost depends on position, since shifting elements in an array or walking to a node in a list changes the work required.
This matters because data structure selection is an engineering decision, not a style preference. Once you can say that an array gives O(1) indexed access but O(n) insertion at the front, and that a linked list reverses that profile, you can justify a choice for a specific use case rather than guessing. That reasoning — matching the operations your program performs most often to the structure that makes them cheap — is the skill the rest of COP3530 builds on.
As you watch, focus on the counting method: how does the presenter decide which statements execute once versus n times, and how do constants and lower-order terms get dropped? Pay attention to the vocabulary of complexity classes so you can recognize O(1), O(n), and O(n^2) patterns on sight, and keep asking yourself which array or list operation each example resembles.
A companion video from the same series that analyzes an algorithm whose running time grows in proportion to the input, arriving at O(n). Expect a loop-based example where the presenter counts how many times each statement executes as a function of n, then simplifies the resulting expression. It should make clear why constants and lower-order terms are discarded in the final notation.
Linear time is the cost of searching an unsorted array or list and of the shifting and traversal work in many insertions and deletions, so this video supplies the analysis pattern you will reuse for all of those operations. Watching it immediately after the constant-time video makes the contrast between O(1) and O(n) concrete.
This video walks through how to determine that an algorithm runs in constant time, counting the operations in a simple code fragment and showing why the total does not grow as the input size increases. Based on its title and the channel's data structures series, it should establish the O(1) notation and the reasoning behind dropping constant factors. It is the shortest of the three and serves as the natural starting point.
O(1) is the cost class behind array access by index, so a focused, step-by-step derivation of constant time gives you the formal justification for a claim you will use constantly. Dinesh Varyani's DSA series is a widely used, beginner-oriented treatment that keeps the counting explicit.
Professor Kevin Wortman surveys the five efficiency classes that come up most often in data structures work: O(1), O(log n), O(n), O(n log n), and O(n^2). Rather than deriving one algorithm in detail, it frames the classes as a ranked vocabulary and, per the description, is built around a slide deck aimed at data structures students. This gives you the comparative picture needed to rank operations against one another.
Comparing list and array operations requires knowing the ordering of complexity classes, not just how to compute one, and this video supplies exactly that frame from a computer science instructor teaching the data structures context. It also previews O(n^2), which appears when operations are nested inside loops.
Together these videos give you the analytical tools that MO3 and MO4 require. The constant-time and linear-time videos teach the counting procedure that lets you classify an operation as O(1) or O(n), which is precisely what MO3 asks you to do for array access and sequential search; the complexity-classes survey adds O(n^2) and establishes the ranking among classes. That ranking is what makes MO4 possible — once you can order the classes, you can weigh an array's cheap indexed access against a list's cheaper front insertion and defend a choice. The videos reinforce MO2 indirectly as well, since the cost of insertion and deletion by position is only meaningful once you can count the shifting or traversal steps involved, and they support the structural comparison in MO1 by giving you a quantitative vocabulary for the differences between the two layouts.
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.