Why Big O Notation Confuses Everyone (And How to Finally Understand It)

If there is one topic in A Level Computing that causes more confusion than almost anything else, it is Big O notation.

Students often say things like:

“I don’t get what the letters mean”
“Is it just maths?”
“Why does it even matter if the code works?”

And that last one is the key.

Because yes — your code might work…
But will it still work when there are a million users?

What Big O Is Really About

Big O notation isn’t just a formula.

It’s a way of answering one simple question:

“How does the time taken (or memory used) grow as the input gets bigger?”

Not when you test it with 10 items…
But when you test it with:

1,000 items
1,000,000 items
or even more

Why Students Struggle

From years of teaching, the main issues are:

1. It’s taught too abstractly

Students see symbols like:

O(n)
O(n²)
O(log n)

…but don’t connect them to real programs.

2. It feels like maths instead of computing

As soon as graphs appear, many students switch off.

3. No real-world context

Without context, it becomes memorisation instead of understanding.

A Simple Example: Searching

Let’s take something simple — finding a name in a list.

Method 1: Linear Search → O(n)

Check each item one by one
Worst case: check everything

If there are 1,000 items → up to 1,000 checks

Method 2: Binary Search → O(log n)

Start in the middle
Eliminate half each time

If there are 1,000 items → about 10 checks

This is the key idea:

Even though both methods “work”…

One is dramatically faster as the data grows.

Understanding the Common Big O Types

Think of them like this:

O(1) → Always the same (fastest)
O(log n) → Grows slowly (very efficient)
O(n) → Grows steadily
O(n log n) → Slightly worse than linear
O(n²) → Gets slow quickly
O(2ⁿ) → Completely impractical very fast!

Why It Matters in the Real World

This isn’t just an exam topic.

Big O is used in:

Search engines
Social media platforms
Banking systems
Game engines

Imagine:

Searching Google using O(n²)…
Or loading Instagram with inefficient algorithms…

They simply wouldn’t work at scale.

How to Actually Understand It (Not Memorise It)

Here’s how I teach it:

Step 1: Start with real problems

Searching, sorting, looping — not formulas

Step 2: Think “what happens when input grows?”

Always ask:

“If I double the data, what happens to the time?”

Step 3: Visualise it

Graphs help — but only after understanding the idea

Step 4: Compare algorithms

Understanding comes from comparison, not isolation

Exam Tip

A typical exam question might ask:

“Compare the efficiency of two algorithms…”

To get top marks:

State the Big O
Explain what it means
Link it to performance with large datasets

Final Thought

Big O notation isn’t about complicated maths.

It’s about thinking like a computer scientist:

“Will this still work when the problem gets big?”

Master that idea — and the rest falls into place.

Need Help With A Level Computing?

At Hemel Private Tuition, we:

Break complex topics into simple ideas
Use real examples (not just theory)
Focus on exam success AND understanding

02 May 2026