DSA — Big O Notation

What is Big O?

Big O notation describes the upper bound of an algorithm's growth rate.

Big O Examples

# O(1) - Constant Time
def get_value(arr, index):
    return arr[index]

# O(log n) - Logarithmic
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# O(n) - Linear
def linear_search(arr, target):
    for i, val in enumerate(arr):
        if val == target:
            return i
    return -1

# O(n²) - Quadratic
def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

Growth Rate Comparison

n	O(1)	O(log n)	O(n)	O(n log n)	O(n²)
1	1	0	1	0	1
10	1	3	10	33	100
100	1	7	100	664	10,000
1000	1	10	1000	9966	1,000,000

Rules for Big O

1. Drop constants: O(2n) → O(n)
2. Drop lower-order terms: O(n² + n) → O(n²)
3. Different inputs = different variables

Mini Practice

1. Determine Big O of simple functions
2. Analyze nested loops
3. Compare algorithm efficiencies
4. Optimize for better Big O

Up Next

Continue with Recursion — recursive problem solving.