How to Learn Big O Notation
Big O notation describes how an algorithm's speed grows as the input grows — the language of coding interviews and performance. There are only a handful of common complexities, and once you match each to a real example, it clicks. This deck teaches them.
There are 12 cards in the deck below. You can read through them, practise them right here with the flip-card player, and then save the deck to study properly with spaced repetition — the method that makes them stick for months, not minutes.
Why big O notation is hard to memorize (and the fix)
The notation looks like math but is really about growth patterns. People struggle to rank them (is O(log n) faster than O(n)?) until they see a concrete example of each.
The fix is active recall plus spaced repetition. Instead of re-reading the list (which feels productive but barely works), you test yourself — pull each answer out of memory — and you review each card on a schedule that stretches over time. Every time you successfully recall a fact, the memory gets stronger and the next review is pushed further out. That's how you go from "I saw it once" to "I just know it."
The fastest way to learn big O notation
- Break it into small batches. Learn the complexities in order from fastest to slowest, pairing each with one everyday algorithm example.
- Test, don't re-read. Look at the question, say the answer out loud before flipping the card. The little struggle to recall is what builds the memory — a smooth re-read does almost nothing.
- Review on a schedule. Spaced repetition shows you each card right before you'd forget it. Get one right and it comes back in a few days, then a week, then a month. Miss one and it comes back sooner.
- Keep sessions short and daily. Five to ten minutes a day beats a two-hour cram every time. Consistency is the whole game.
One fact per card. Lower on the list = slower. O(1) is best; O(2ⁿ) is a red flag in interviews.
The full deck: Big O Notation
Here's every card in the set. Practise them above, or save the deck and let spaced repetition schedule your reviews automatically.
| Complexity | Meaning / example |
|---|---|
| What is O(1)? | Constant time — same speed regardless of input size (array lookup) |
| What is O(log n)? | Logarithmic — halves the problem each step (binary search) |
| What is O(n)? | Linear — time grows with input size (a single loop) |
| What is O(n log n)? | The speed of efficient sorts (merge sort, quicksort average) |
| What is O(n²)? | Quadratic — nested loops over the input (bubble sort) |
| What is O(2ⁿ)? | Exponential — doubles each step (naive recursion, brute force) |
| Rank fastest to slowest: O(n), O(1), O(n²). | O(1), O(n), O(n²) |
| Which is faster, O(log n) or O(n)? | O(log n) |
| What does Big O describe? | How an algorithm's time or space grows as input grows |
| What complexity is a binary search? | O(log n) |
| What complexity is a simple nested loop over n items? | O(n²) |
| What is the best (fastest) common complexity? | O(1) — constant time |
Save this deck and actually remember it
Create a free account, keep this 12-card deck, and we'll schedule every review at the perfect moment. First deck free forever — no credit card.
Study this deck free →FAQ: learning big O notation
How long does it take to learn big O notation?
Most people can lock in big O notation within one to three weeks of short daily sessions. With spaced repetition doing 10–12 cards a day, you'll recognise them within days and recall them reliably within a couple of weeks.
What's the best way to memorize big O notation?
Active recall plus spaced repetition. Test yourself instead of re-reading, and review on a schedule that spaces the cards out over time. Flashcards are built for exactly this — which is why the deck above is the fastest path.
Is this deck free?
Yes. You can practise all 12 cards on this page for free with no account. Sign up (also free) to save the deck and let spaced repetition schedule your reviews so it sticks long-term.