Understanding Time Complexity Notation

Time complexity notation helps describe how the runtime of an algorithm changes as the input size grows. Instead of focusing on exact execution time, we use mathematical functions to compare performance at scale. The most common notations are Big-O, Big-Ω, and Big-Θ.

Big-O Notation (O)

Big-O describes the upper bound — the worst-case scenario. It gives us a way to guarantee that an algorithm won't perform worse than a certain threshold.

function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) return i;
  }
  return -1;
}

In the worst case, the target is at the end of the array or not present. The function runs through the entire array, so the time complexity is O(n).

Big-Ω Notation (Ω)

Big-Ω gives us the lower bound — the best-case scenario. It tells us how well an algorithm can perform in ideal conditions.

Using the same linearSearch example, if the target is the first element, the loop ends immediately. In this case, the time complexity is Ω(1), meaning it completes in constant time.

Big-Θ Notation (Θ)

Big-Θ describes the tight bound — when an algorithm's best and worst cases grow at the same rate. If an algorithm is always linear regardless of input conditions, we say it is Θ(n).

This notation is less commonly used in isolation, but it’s helpful when you want a complete picture of an algorithm's growth.

Why This Matters

Time complexity helps you:

• Predict how an algorithm scales
• Choose between alternative solutions
• Spot inefficient code before performance becomes a problem

Understanding how to apply these notations is a key skill in writing scalable, efficient software. When designing algorithms, always consider how performance changes as inputs grow — and aim to choose or design solutions with the best time complexity you can afford.