+- The Lumin Archive (https://theluminarchive.co.uk)
+-- Forum: The Lumin Archive — Core Forums (https://theluminarchive.co.uk/forumdisplay.php?fid=3)
+--- Forum: Computer Science (https://theluminarchive.co.uk/forumdisplay.php?fid=8)
+---- Forum: Programming & Algorithms (https://theluminarchive.co.uk/forumdisplay.php?fid=26)
+---- Thread: Time Complexity Made Simple: Big-O Explained With Real Code (/showthread.php?tid=347)
Time Complexity Made Simple: Big-O Explained With Real Code - Leejohnston - 11-17-2025
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.