[Leejohnston]

Thread 5 — Time Complexity Made Simple 
Understanding Big-O With Real Python Code

The Hidden Measure of Algorithm Efficiency

Every program runs… but not every program scales. 
Time complexity (Big-O notation) tells us how the performance of an
algorithm grows as the input size increases.

This thread gives members a clear, practical understanding using real,
runnable Python examples.

---

1. Why Big-O Matters

Big-O answers a single question:

“If my input gets bigger… how much slower will my algorithm become?”

It looks at:
• The number of operations 
• How performance grows with input size 
• Worst-case behaviour 

Big-O is NOT about exact time — it’s about growth trends.

---

2. O(1) — Constant Time

The algorithm takes the same amount of time no matter how large the input is.

Example: Get an item from a list by index

Code:

def get_first(nums):
    return nums[0]

print(get_first([10, 20, 30]))

No loops. No scanning. Just constant work.

---

3. O(n) — Linear Time

Performance grows directly with input size.

Example: Sum all numbers

Code:

def total(nums):
    s = 0
    for x in nums:
        s += x
    return s

print(total([1,2,3,4,5]))

Double the list size → double the operations.

---

4. O(n²) — Quadratic Time

Common in nested loops.

Example: Check all pairs

Code:

def print_pairs(nums):
    for a in nums:
        for b in nums:
            print(a, b)

print_pairs([1,2,3])

If the list doubles, runtime *quadruples*. 
This grows extremely fast — beginners often underestimate it.

---

5. O(log n) — Logarithmic Time

One of the fastest scaling behaviours. 
Each step reduces the problem size dramatically.

Example: Binary Search

Code:

def binary_search(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

print(binary_search([1,2,3,4,5,6,7,8], 6))

Searching 1 million items? 
Binary search needs only ~20 steps.

---

6. O(n log n) — The Sweet Spot of Fast Sorting

Most efficient comparison-based sorting algorithms run in O(n log n).

Example: Python’s built-in sort

Code:

nums = [9,1,8,2,7,3,6]
nums.sort()
print(nums)

Python uses Timsort — a hybrid O(n log n) algorithm used in real-world systems.

---

7. Visual Summary

Here’s how runtime grows as “n” increases:

• O(1) → flat 
• O(log n) → slow curve 
• O(n) → straight diagonal 
• O(n log n) → steeper curve 
• O(n²) → explosive growth 

Understanding this helps members write faster, smarter code.

---

8. Real Practical Advice for Users

Choose O(log n) or O(n) whenever possible. 
Avoid O(n²) for large datasets. 
Know that built-ins like:

• sorted() 
• set() membership 
• dict lookups 

…are extremely fast because they rely on optimised algorithms.

---

Final Thoughts

Big-O is the language of performance. 
Once members understand how algorithm growth works, they can design
programs that scale from tiny scripts to real production systems.

This thread gives them a clear foundation, plus working examples they
can run and modify immediately.