Understanding Asymptotic Notation Link to heading

When we write code or design an algorithm to solve a problem, it consists of a series of steps such as:

  • Sequencing (executing steps in order)
  • Value assignment (e.g., x = 5)
  • Selection (conditional logic like if/else)
  • Iteration (loops)

Each step takes some amount of time to execute. When we add up the time taken by all these steps, we get the runtime of the code or algorithm.

Why Do We Measure Time and Space? Link to heading

When code runs, it consumes:

  • Time (CPU operations)
  • Space (memory)

Measuring how much time and space an algorithm will use is called Time and Space Complexity.

Time is usually more valuable than space because hardware storage is cheaper and easier to scale, so we often focus more on time complexity.

Why Do We Need Asymptotic Notation? Link to heading

If we test our algorithm on small input sizes like 10, 20, or even 100 elements, the difference between two algorithms may not be noticeable.

But when the input size grows — to millions or tens of millions — performance differences become very obvious.

Real-world systems must handle large scale inputs. For example:

  • A live streaming platform may serve billions of views during a popular cricket match.
  • A large URL shortener service may receive thousands of URL-shortening requests per second, not just a few dozen.

Our system must be resilient enough to handle all kinds of load:

  • Best case: 10 requests
  • Average case: 1,000 requests
  • Worst case: 10,000+ requests

To evaluate algorithm performance across these scenarios, we need a mathematical tool.

What Is Asymptotic Notation? Link to heading

Asymptotic Notation is a mathematical tool used to describe how the runtime or space usage of an algorithm grows as the input size becomes very large.

It helps us understand algorithm efficiency in three cases:

  • Best Case → Ω (Omega)
  • Average Case → Θ (Theta)
  • Worst Case → O (Big-O)

Asymptotic notation ignores machine-specific details and focuses on how the algorithm scales, which is what matters in large-scale systems.

Summary Link to heading

We use asymptotic notation to:

  • Measure algorithm performance
  • Compare different solutions
  • Predict behavior on large inputs
  • Ensure system resilience in all scenarios (best, average, worst)

This helps us design scalable, efficient, and reliable systems.