Time Complexity Calculator

Estimate algorithm time complexity using Big-O notation. Analyze loop patterns, recursion, and algorithm presets with interactive growth visualizations and educational explanations.

📊

Time Complexity Calculator

Estimate Big-O time complexity by describing your algorithm, configuring loops and recursion, or comparing growth rates visually. All analysis runs locally in your browser.

Describe Your Algorithm

Algorithm Description

Try: "nested loop", "binary search", "merge sort"

Quick Presets

Input Size (n): 100

105001,000

Complexity Result

Describe an algorithm to detect complexity

Growth Visualization

Big-O Reference at n = 100

O(1)Constantexcellent1 ops

O(log n)Logarithmicexcellent7 ops

O(n)Lineargood100 ops

O(n log n)Linearithmicgood664 ops

O(n²)Quadraticfair10.0K ops

O(n³)Cubicpoor1.0M ops

O(2ⁿ)Exponentialterrible∞ ops

O(n!)Factorialcatastrophic∞ ops

How to Use the Time Complexity Calculator

Three Analysis Modes

1Pattern Detector: Describe your algorithm in plain English (e.g. 'nested loop', 'binary search', 'merge sort'). The tool auto-detects the Big-O complexity with an explanation.
2Loop Analyzer: Select the number of nested loops and recursion type from dropdowns. The tool calculates the resulting complexity — great for interview practice.
3Growth Comparator: Select multiple complexities to see their growth rates side-by-side on the chart. Adjust the input size slider to see how they diverge.
4History: Save analyses to browser history for review. Click any entry to reload it into the detector.

Key Features

✓Keyword-based Big-O pattern detection
✓Loop + recursion configuration mode
✓Interactive growth comparison chart
✓All 8 Big-O complexities explained
✓Real-world analogies for each complexity
✓Pseudo-code examples for each pattern
✓Operations count at any input size n
✓Quick algorithm presets (sort, search, etc.)
✓Export analysis as TXT
✓Analysis history saved in browser
✓Color-coded complexity reference table
✓Mobile-friendly canvas chart

Big-O Complexity Quick Reference

Complexity	Name	n=10	n=100	n=1,000	Rating
O(1)	Constant	1	1	1	Excellent
O(log n)	Logarithmic	3	7	10	Excellent
O(n)	Linear	10	100	1,000	Good
O(n log n)	Linearithmic	33	664	9,966	Good
O(n²)	Quadratic	100	10,000	1,000,000	Fair
O(n³)	Cubic	1,000	1,000,000	1B	Poor
O(2ⁿ)	Exponential	1,024	~10³⁰	∞	Terrible
O(n!)	Factorial	3.6M	~10¹⁵⁷	∞	Catastrophic

Common Algorithms and Their Complexities

Algorithm	Best Case	Average Case	Worst Case	Space
Binary Search	O(1)	O(log n)	O(log n)	O(1)
Linear Search	O(1)	O(n)	O(n)	O(1)
Bubble Sort	O(n)	O(n²)	O(n²)	O(1)
Merge Sort	O(n log n)	O(n log n)	O(n log n)	O(n)
Quick Sort	O(n log n)	O(n log n)	O(n²)	O(log n)
Heap Sort	O(n log n)	O(n log n)	O(n log n)	O(1)
Hash Table Lookup	O(1)	O(1)	O(n)	O(n)
Recursive Fibonacci	O(1)	O(2ⁿ)	O(2ⁿ)	O(n)

Frequently Asked Questions

What is Big-O notation?

Big-O notation describes the upper bound of an algorithm's time or space complexity as input size grows. It focuses on the dominant term and ignores constants, giving a machine-independent way to compare algorithm efficiency.

What is the difference between best, average, and worst case?

Best case (Ω) is the minimum operations, average case (Θ) is the expected operations, and worst case (O) is the maximum. Big-O typically describes worst case. For example, quicksort is O(n log n) on average but O(n²) worst case with bad pivots.

Why is O(log n) so efficient?

Logarithmic algorithms halve the problem space at each step. For n = 1,000,000, O(log n) only needs ~20 steps, while O(n) needs 1,000,000. This is why binary search is vastly superior to linear search on sorted data.

When is O(n²) acceptable?

Quadratic complexity is acceptable for small inputs (n < 1,000 in most cases). Bubble sort or insertion sort are fine for small arrays and have low constant factors. For large datasets, O(n log n) algorithms like merge sort are required.

How do I reduce exponential complexity?

Dynamic programming (memoization or tabulation) eliminates redundant recursive calls. Fibonacci changes from O(2ⁿ) to O(n) with memoization. Greedy algorithms and approximations can also replace exact exponential solutions for NP-hard problems.