Big O Notation Explained: How to Analyze Algorithm Efficiency

Imagine you're sorting a list of 10,000 names. You write two different sorting functions. Both work correctly, but which one should you use? If you time them on your laptop, one might finish in 0.2 seconds, the other in 2 seconds. But what if you run them on a faster server? Or with 100,000 names? The raw time numbers become meaningless — they depend on the machine, the language, the compiler, even the weather (okay, maybe not the weather). Big O notation solves this by describing how the number of operations grows as the input size grows, ignoring constant factors and lower-order terms. It's the universal language for comparing algorithm efficiency, allowing you to say "this algorithm scales well" or "this one will choke on large inputs" without running a single benchmark. Without Big O, you're guessing. With it, you can reason about performance mathematically, before you even write the code.

Imagine you're measuring how long it takes to sort a deck of cards as the deck grows. A simple method like bubble sort might take roughly $n^2$ comparisons for $n$ cards, while a smarter method like merge sort takes about $n{\log }_{2}n$ comparisons. Big O notation is a way to classify these growth patterns into families. s $n$ gets very large (like sorting a million cards), the term that grows fastest dominates everything else. For $3n^2+5n+100$, when $n=1000$, the $3n^2$ term is $3,000,000$ while $5n$ is only $5,000$ — the $n^2$ part determines the shape of the curve. Big O drops constants (like the 3) and lower-order terms (like $5n$ and $100$), leaving just $O(n^2)$. This gives us a high-level label for the algorithm's efficiency: constant $O(1)$, logarithmic $O(\log n)$, linear $O(n)$, linearithmic $O(n\log n)$, quadratic $O(n^2)$, cubic $O(n^3)$, exponential $O(2^n)$, and factorial $O(n!)$. Each represents a distinct growth rate family. The model is not about exact time — it's about scalability: how much slower does the algorithm get when you double the input size? For $O(n)$, doubling $n$ doubles the time; for $O(n^2)$, doubling $n$ quadruples the time; for $O(\log n)$, doubling $n$ adds a constant amount of time. This mental model lets you quickly reason about whether an algorithm will work for your expected data sizes.

Let's put the model into action with a concrete function. Consider this JavaScript function that finds the maximum product of any two numbers in an array:

function maxProduct(arr) {
  let max = -Infinity;
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      let product = arr[i] * arr[j];
      if (product > max) {
        max = product;
      }
    }
  }
  return max;
}

Now apply the same counting method from the worked example.

function countEvenSumPairs(arr) {
  let count = 0;
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if ((arr[i] + arr[j]) % 2 === 0) {
        count++;
      }
    }
  }
  return count;
}

You've learned to derive Big O from code. Now let's apply that skill to a realistic decision: choosing between two search algorithms for a large, unsorted dataset.