Big O, in Plain Language

The plain-language idea

"Big O" is one of the phrases that scares people away from this whole topic, so let's take it apart slowly. By the end of this lesson, it will feel like common sense, because it already is common sense — it just got a math name stapled onto it.

Picture two ways of finding a name in a phone book. The first way: open to a random page, and if the name you want comes later in the alphabet, flip forward; if it comes earlier, flip back; keep narrowing the gap. You'd find almost any name in ten flips or fewer, even in a book with a thousand pages. The second way: start at page one, and read every single name until you find the one you want. That could take you all the way to the last page.

Both ways work. But they don't get slower at the same rate when the phone book gets bigger. Double the pages, and flipping-and-narrowing barely notices — maybe one extra flip. Double the pages, and reading-every-name takes roughly twice as long. That difference — not the exact number of steps, but how the number of steps grows as the input grows — is the entire idea behind Big O.

Big O is a way of describing that growth pattern with a short label, so programmers can talk about it without re-explaining it every time. "Reading every name" is O(n): the work grows in a straight line with the size of the input. "Flipping and narrowing" is O(log n): the work barely grows at all, even as the input gets huge. You'll meet the exact vocabulary for these labels in the next lesson — for now, the only thing to hold onto is: Big O answers "how does the work grow?", not "exactly how many steps is that?"

See it in a real thing: two ways to search

// Way 1: check every name, one at a time, until we find it (or don't).
// This is the "read every page" approach.
function findLinear(names, target) {
  for (let i = 0; i < names.length; i++) {
    if (names[i] === target) return i; // found it, stop here
  }
  return -1; // never found it
}

// Way 2: the list is already sorted alphabetically, so we can
// narrow the search in half each time, like flipping a phone book.
function findByNarrowing(sortedNames, target) {
  let low = 0;
  let high = sortedNames.length - 1;

  while (low <= high) {
    const mid = Math.floor((low + high) / 2); // check the middle
    if (sortedNames[mid] === target) return mid; // found it
    if (sortedNames[mid] < target) low = mid + 1; // target is later, narrow up
    else high = mid - 1; // target is earlier, narrow down
  }

  return -1; // never found it
}

What people usually miss

Watch out

• They think Big O measures exact speed. It doesn't measure seconds or exact step counts. It describes a growth pattern — how the work scales as input grows, ignoring the small stuff.
• They think a "faster-looking" approach is always better. Narrowing only works because the list was already sorted. Sorting it first costs its own work. Big O helps you reason about trade-offs like this, not just pick a winner blindly.
• They panic at the letter-and-parentheses notation. O(n), O(log n) — these are just short labels for growth patterns, the same way "MPH" is a short label for a speed. The next lesson walks through exactly what each one looks like in code.

The genealogy: where this leads

This is the same idea you'll use to judge almost every solution for the rest of this track, and in interviews well beyond it. The next lesson takes this same phone-book intuition and connects it to specific labels — O(1), O(n), O(n^2), O(log n) — so you can recognize them by sight.