Understanding and Calculating Time and Space Complexity

Step 1: Understanding Time Complexity

Time complexity is a measure of the time an algorithm takes to complete as a function of the length of the input.


Think of time complexity like preparing a meal. The more ingredients (input size) you have, the more time it might take to prepare the meal (algorithm execution).

Example in Python

Consider a simple linear search:

def linear_search(arr, x):
    for i in range(len(arr)):
        if arr[i] == x:
            return i
    return -1

Time Complexity: O(n) – As the size of the array arr increases, the time to search increases linearly.

Step 2: Understanding Space Complexity

Space complexity is a measure of the amount of memory space an algorithm uses in relation to the length of the input.


Think of space complexity as the number of pots and pans you use to cook a meal. More complex meals (algorithms) might require more kitchenware (memory).

Example in Python

Consider an algorithm that stores intermediate results in a list:

def calculate_squares(n):
    squares = []
    for i in range(n):
        squares.append(i * i)
    return squares

Space Complexity: O(n) – The space needed grows linearly with the input n.

Step 3: Calculating Time Complexity

  1. Identify the Basic Operations: In your code, look for loops, recursive calls, and other operations that change with input size.
  2. Count the Operations: Estimate how many times these operations are executed in terms of input size.
  3. Formulate Time Complexity: Express the number of operations in Big O notation (e.g., O(n), O(log n), O(n^2)).

Step 4: Calculating Space Complexity

  1. Consider Variables and Data Structures: Note all the variables and data structures used in the algorithm.
  2. Count the Memory Usage: Estimate how the memory usage scales with input size.
  3. Formulate Space Complexity: Express this in Big O notation.

Step 5: Consider Worst, Average, and Best Cases

  • Worst Case: The maximum time or space the algorithm will take.
  • Average Case: The expected time or space for a typical input.
  • Best Case: The minimum time or space for the most favorable input.

Example: Calculating Time Complexity

Consider a simple for loop:

for i in range(n):
  • Basic Operation: The print statement.
  • Count the Operations: It runs n times.
  • Time Complexity: O(n).

Example: Calculating Space Complexity

Consider an algorithm that creates a new list:

new_list = [i for i in range(n)]
  • Variables/Data Structures: One list of size n.
  • Count the Memory Usage: It grows linearly with n.
  • Space Complexity: O(n).


To effectively calculate time and space complexity, understand the operations your algorithm performs, how they scale with input size, and express them in Big O notation. Remember, complexity analysis helps in predicting algorithm efficiency and resource usage, making it a cornerstone of algorithm design and optimization.

Hello, I’m Anuj. I make and teach software.

My website is free of advertisements, affiliate links, tracking or analytics, sponsored posts, and paywalls.
Follow me on LinkedIn, X (twitter) to get timely updates when I post new articles.
My students are the reason this website exists, crafted with the affection and dedication they’ve shown. ❤️

Feedback Display