Big O notation is the standard language for describing how an algorithm's running time or memory use grows as the input size grows. Rather than measuring seconds on a particular machine, Big O captures an upper bound on the rate of growth, which lets us compare algorithms in a way that stays meaningful across hardware, languages, and compilers. In this topic we revisit that idea carefully: what the notation actually asserts, the common growth classes you will see again and again (constant, logarithmic, linear, linearithmic, quadratic, exponential), and why constants and lower-order terms are dropped when only the dominant term matters at scale.
This matters throughout COP3530 because nearly every data structure decision you make is justified with a complexity argument. When you choose a hash table over a sorted array, or a balanced tree over a linked list, you are claiming something about growth rates. Reading Big O fluently also means recognizing patterns in code: a single loop over n elements, nested loops, a loop that halves the search space each iteration, or a recursive call structure each map to a predictable class.
As you watch, pay attention to three things. First, how each presenter defines Big O formally versus how they use it informally. Second, how they move from a piece of code to a growth expression and then simplify it. Third, the connection between Big O and worst-case analysis — Big O is often used for worst-case guarantees, but the notation itself and the case being analyzed are two separate choices, and keeping them distinct will save you confusion later in this module.
A compact overview of asymptotic notation that covers Big O alongside Theta and Omega, explaining what each bound expresses about an algorithm's growth. Expect formal-style definitions and comparisons that place Big O in context as the upper bound rather than treating it in isolation. The video is part of a series and references an introductory companion video.
Michael Sambol's algorithm videos are widely used for their precision and brevity, and this one directly addresses the distinction between upper, lower, and tight bounds that the topic depends on. It is the best short reference for understanding what Big O represents as opposed to what it is casually used to mean.
A longer, example-driven lesson on time complexity and Big O aimed at students learning data structures and algorithms, with code in Java and C++. Based on its title and description, it walks through analyzing and calculating complexity for code segments, which typically means loops, nested loops, and the simplification steps that drop constants and lower-order terms. It is the opening video of a full DSA course series.
The extended runtime allows for worked calculations rather than definitions alone, which supports the subtopics on interpreting Big O for algorithm patterns and on dropping constants. Its very large view count reflects its popularity as an accessible entry point for exactly this material.
A brief, mathematically oriented introduction to Big-O notation from the Mathispower4u channel. It is likely to present the formal definition in terms of functions, constants, and a threshold value, and to show how one function is bounded above by another. The short length makes it a focused look at the underlying mathematics.
This video supplies the formal, mathematical grounding that complements the code-centric treatments, which is useful when you need to justify why constants and lower-order terms can be discarded. Mathispower4u is a long-running instructional math channel with a consistent, step-by-step presentation style.
Together these videos cover both halves of the topic. The Sambol video separates Big O from Omega and Theta and explains what each bound claims, supporting MO1 and the reasoning about analytical goals in MO5. The Mathispower4u video supplies the formal definition that justifies dropping constants and lower-order terms, while the Anuj Kumar Sharma video applies that reasoning to actual code, giving you practice classifying single loops, nested loops, and similar patterns into growth classes as required by MO3. The emphasis across all three on upper bounds and worst-case framing prepares you for the case-by-case derivations in MO2, and the comparison of growth classes gives you the vocabulary needed to argue about scalability and algorithm selection in MO4.
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.