Computational complexity is the study of how the cost of running an algorithm grows as the amount of data it handles grows. Instead of timing code with a stopwatch — which depends on your machine, your language, and what else your computer is doing — we count the operations an algorithm performs as a function of the input size, usually called n. This gives us a machine-independent way to compare two approaches before we ever write them.
This matters in COP3530 because almost every decision you make about data structures is really a decision about cost. Reading the tenth item of an array, searching an unsorted list, or inserting at the front of a structure all have different costs, and those differences only become visible when n is large. Complexity analysis is the vocabulary you will use for the rest of the course to justify why one structure beats another for a given job.
As you watch, pay attention to four things: how each presenter identifies the input size, which operations they decide to count, how they distinguish best, average, and worst cases, and why they throw away constants and lower-order terms. That last habit — abstraction — can feel like cheating at first, but it is what lets us say something true about an algorithm's behavior at any scale rather than a single measurement on one computer.
A fast, focused introduction to what it means to analyze an algorithm, covering how we reason about running time in terms of input size rather than wall-clock seconds. The video is framed as the first part of a short series, with a follow-up on asymptotic notation, so it likely sets up the counting-operations mindset that Big O then formalizes. Code examples are referenced in the description.
Michael Sambol's algorithm videos are widely used by CS students for their brevity and correctness, and this one is deliberately scoped as the conceptual starting point — ideal for the "What Is Computational Complexity?" and "Input Size as the Key Variable" subtopics before you meet the notation itself.
A longer, lecture-style treatment of complexity analysis that focuses specifically on best case, average case, and worst case. Expect worked reasoning about how the same algorithm can behave very differently depending on the particular input it receives, and why we usually quote the worst case when comparing algorithms.
This is the most direct coverage of the "Worst, Best, and Average Cases" subtopic, and its university-course framing means it spends enough time on the distinction for the ideas to stick rather than rushing past them.
A compact explanation of time complexity that walks through how to count the cost of individual operations in a piece of code and express the total as a function of n. Videos in this series are animation-driven and typically build from simple statements and loops up to a general running-time expression.
Dinesh Varyani's DSA series is a popular, well-structured resource, and this video connects the abstract idea of complexity to concrete line-by-line operation costs — exactly the bridge needed for the "Operations and Their Costs" and "The Purpose of Abstraction in Complexity" subtopics.
Together these videos give you the analytical language the rest of the module depends on. Sambol's introduction and Varyani's operation-counting walkthrough prepare you to classify list and array operations as O(1), O(n), or O(n squared) (MO3) by making input size and per-operation cost explicit, which in turn supports describing how the cost of access, search, insertion, and deletion varies by position (MO2). Dr. Skiles's treatment of best, average, and worst cases gives you the precision needed to compare structures honestly rather than citing a single number, which is the foundation for evaluating efficiency trade-offs and justifying a data structure choice for a specific use case (MO4). While these videos do not themselves contrast array and list memory layouts (MO1), they supply the cost framework you will apply to that comparison in the rest of the module.
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.