So far in this course you have learned the vocabulary of asymptotic analysis — Big O, Omega, and Theta — and the mechanics of counting operations. This topic puts that vocabulary to work on algorithms you already know how to code: linear search, binary search, bubble sort, selection sort, and merge sort. The goal is not to memorize a table of complexities but to be able to reconstruct each result from the structure of the algorithm itself.
That skill matters because the same handful of structural patterns reappear constantly. A single pass over n elements gives you O(n); a loop nested inside another loop over the same data gives you O(n^2); repeatedly halving a search space gives you O(log n); and splitting a problem in half and merging the results gives you O(n log n). Once you can recognize these patterns, you can analyze unfamiliar code without memorizing anything new.
As you watch the videos below, pay attention to three things: which operation is being counted as the dominant one, how the count changes between the best, average, and worst case, and why a particular notation is chosen to report the result. Notice especially that an algorithm can have different best- and worst-case behavior — optimized bubble sort is the classic example — and that reporting only Big O hides that distinction. Try pausing each video and deriving the bound yourself before the presenter states it.
A compact walkthrough of the binary search algorithm, covering how the search range is repeatedly halved against a sorted array and including a link to a Python implementation. Expect a trace of the algorithm on example data alongside a statement of its logarithmic running time.
Binary search is the canonical example of the recursive-halving pattern, and this short, widely-viewed explanation from a well-known algorithms channel gives you a concrete mental model for why repeated halving yields O(log n) rather than O(n).
A broader survey that collects the time and space complexities of the standard sorting algorithms and relates them to Big-O notation. Based on its title and series context, it is likely to cover bubble sort, selection sort, insertion sort, merge sort and others, comparing their best, average and worst cases side by side.
It directly supports the bubble sort, selection sort, and merge sort subtopics in one place, and the side-by-side comparison is useful practice for justifying why one algorithm scales better than another.
A focused lecture on the optimized version of bubble sort — the variant that stops early when a pass makes no swaps — and why that modification produces O(n) best-case behavior. The video explains the reasoning behind the best case in contrast to the usual quadratic result.
It is the clearest illustration in this set of why best case and worst case must be derived separately, which is exactly the distinction you need when deciding between Big O, Omega, and Theta for a given algorithm.
Together these videos move from a single algorithm to a comparative view. The binary search video gives you the recursive-halving pattern behind O(log n), and the optimized bubble sort video shows how a small implementation change separates best-case from worst-case behavior — both directly supporting the derivation of best, worst, and average cases (MO2) and the classification of loop and halving patterns into growth-rate categories (MO3). The sorting comparison video assembles the complexities of bubble, selection, and merge sort in one frame, which is the raw material for comparing scalability and time-space trade-offs when selecting an algorithm (MO4). Where the videos report a single Big O figure, use the best-case/worst-case contrast raised in the bubble sort video to practice articulating which bound you actually need and why (MO1, 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.