What is Big-O notation?

Big-O notation describes how the running time or space of an algorithm grows as the input size grows. It gives an upper bound on the growth rate, ignoring constant factors.

What are the most common time complexities?

Common complexities are O(1), O(log n), O(n), O(n log n), O(n²), O(2^n), and O(n!).

What is the difference between Big-O and Big-Theta?

Big-O gives an asymptotic upper bound. Big-Theta gives a tight bound, meaning it bounds the function from above and below asymptotically.

Big-O Complexity Explorer

Interactive Big-O tool to explore algorithm complexity. Compare O(1), O(log n), O(n), O(n log n), O(n²) and more. Estimate operations for your input size n, see examples, and learn how to read asymptotic notation.

Quick Explorer

Choose a complexity class, set n, then tap Estimate growth to view how the operations count explodes.

Complexity class

n (input size)

Try powers of 10 or your own dataset size.

Estimated steps

—

Complexity —

Growth feeling —

Example —

How to use this explorer

Pick a complexity class, type in the number of elements, and click Estimate growth. The right panel converts the class into an operation count that you can compare to other classes.

The calculator uses the textbook formulas for each complexity. It assumes Big-O notation measures the dominant term, counts operations, and ignores constant factors to focus on growth rate.

Methodology

We compute the estimated steps by evaluating the mathematical definition of each complexity class. Integer fields and safe parsing ensure no NaN/Infinity appears when you experiment with large n.

How to read Big-O

Big-O notation abstracts away constant factors and lower-order terms. When an algorithm is O(n), its running time grows linearly with the input size. O(n²) means doubling n quadruples the work.

A function f(n) is O(g(n)) if there exist positive constants c and n₀ such that for all n ≥ n₀,
f(n) ≤ c · g(n)

As data scales, the fastest-growing term dominates performance. That is why engineers evaluate Big-O before choosing algorithms: lower classes win for large n even if they feel slower for small inputs.

Steps to expose Big-O:

Count how many times the innermost statement runs.
Express that count in terms of n, the input size.
Keep the fastest growing term and drop constants → that's the Big-O.

Full original guide (expanded)

Quick Explorer (reference)

The hero above exposes the same controls from the legacy page. Use it to choose complexity, select n, and then read the estimates below.

Complexity

—

Estimated steps

—

Growth feeling

—

Example

—

Results update immediately after you click Estimate growth.

Compare common complexities for the same n

Try 10, 100, 1000…

Class	Formula used	Steps @ n	Comment
Click “Compare” to fill the table.

Common algorithms and Big-O

Algorithm	Time	Notes
Linear search	O(n)	Scan one by one.
Binary search	O(log n)	Requires sorted array.
Merge sort	O(n log n)	Optimal general sort.
Bubble sort (worst)	O(n²)	Educational, not optimal.
DFS / BFS	O(V + E)	Graph traversal.
Power set generation	O(2ⁿ)	Exponential blow-up.
TSP exact (brute force)	O(n!)	Factorial complexity.

Related algorithm tools

Tip

If two algorithms have different Big-O classes, the one with the lower class will win for sufficiently large n, even if it’s slower for small inputs.

Formulas

Big-O inequality:

A function f(n) is O(g(n)) if there exist constants c and n₀ such that
f(n) ≤ c · g(n) for every n ≥ n₀.

Steps include counting the innermost statement, expressing the count in terms of n, and keeping the fastest growing term.

Citations

NIST — Weights and measures — https://www.nist.gov/pml/weights-and-measures
FTC — Consumer advice — https://consumer.ftc.gov/

Changelog

0.1.0-draft — 2026-01-19: Initial draft (review required).

✓ Verified by Ugo Candido Last Updated: 2026-01-19 Version 0.1.0-draft

Version 1.5.0