Visualizing O(n) using Python

Time complexity is a fundamental concept in computer science that measures how an algorithm's runtime changes as the input size grows. O(n) represents linear time complexity, where execution time increases proportionally with input size. Understanding and visualizing O(n) helps developers write efficient code and analyze algorithm performance.

What is O(n) Time Complexity?

O(n) indicates that an algorithm's execution time grows linearly with the input size 'n'. If you double the input, the execution time roughly doubles too. The most common example is a simple loop that processes each element once ?

def linear_search(arr, target):
    for i in range(len(arr)):  # O(n) operation
        if arr[i] == target:
            return i
    return -1

# Example usage
numbers = [1, 3, 5, 7, 9, 11]
result = linear_search(numbers, 7)
print(f"Target found at index: {result}")

Target found at index: 3

Visualizing O(n) - Method 1: Execution Time

We can visualize O(n) by measuring actual execution time for different input sizes ?

import time
import matplotlib.pyplot as plt

def sum_algorithm(n):
    total = 0
    for i in range(n):
        total += i
    return total

# Test with different input sizes
input_sizes = []
execution_times = []

for n in range(1000, 11000, 1000):
    start_time = time.time()
    sum_algorithm(n)
    end_time = time.time()
    
    input_sizes.append(n)
    execution_times.append(end_time - start_time)

# Create the plot
plt.figure(figsize=(8, 6))
plt.plot(input_sizes, execution_times, 'b-o', linewidth=2, markersize=6)
plt.xlabel('Input Size (n)')
plt.ylabel('Execution Time (seconds)')
plt.title('O(n) Time Complexity Visualization')
plt.grid(True, alpha=0.3)
plt.show()

This creates a linear graph showing how execution time increases proportionally with input size.

Visualizing O(n) - Method 2: Operation Count

Instead of measuring time, we can count the number of operations performed ?

import matplotlib.pyplot as plt

def count_operations(n):
    operations = 0
    total = 0
    
    for i in range(n):
        total += i
        operations += 1  # Count each addition
    
    return operations

# Test with different input sizes
input_sizes = list(range(1000, 11000, 1000))
operation_counts = []

for n in input_sizes:
    ops = count_operations(n)
    operation_counts.append(ops)

# Create the plot
plt.figure(figsize=(8, 6))
plt.plot(input_sizes, operation_counts, 'r-s', linewidth=2, markersize=6)
plt.xlabel('Input Size (n)')
plt.ylabel('Number of Operations')
plt.title('O(n) Operations Count Visualization')
plt.grid(True, alpha=0.3)
plt.show()

# Display some data points
print("Input Size -> Operations")
for i in range(0, len(input_sizes), 2):
    print(f"{input_sizes[i]:,} -> {operation_counts[i]:,}")

Input Size -> Operations
1,000 -> 1,000
3,000 -> 3,000
5,000 -> 5,000
7,000 -> 7,000
9,000 -> 9,000

Comparison with Other Time Complexities

Let's compare O(n) with other common time complexities ?

import matplotlib.pyplot as plt
import numpy as np

# Define different time complexities
n_values = np.range(1, 101)
o_1 = np.ones(len(n_values))          # O(1) - constant
o_n = n_values                        # O(n) - linear  
o_n_squared = n_values ** 2           # O(n²) - quadratic

plt.figure(figsize=(10, 6))
plt.plot(n_values, o_1, label='O(1) - Constant', linewidth=2)
plt.plot(n_values, o_n, label='O(n) - Linear', linewidth=2)
plt.plot(n_values, o_n_squared, label='O(n²) - Quadratic', linewidth=2)

plt.xlabel('Input Size (n)')
plt.ylabel('Time Units')
plt.title('Time Complexity Comparison')
plt.legend()
plt.grid(True, alpha=0.3)
plt.ylim(0, 1000)
plt.show()

Real-World O(n) Examples

Conclusion

O(n) linear time complexity creates straight-line graphs when plotting execution time or operations against input size. This visualization helps developers understand algorithm efficiency and make informed decisions about performance optimization in their applications.