Early known algorithm; raises “how many steps” depends on input size

Number theory/analysis informally studies computational effort (e.g., Gauss), not yet formal complexity theory

Motivates formal reasoning about what can be computed/proven within a system

λ-calculus and Turing machines enable precise definitions of time/space as resources

Real constraints (memory, CPU time) push systematic performance analysis

Big-O/Ω/Θ become standard for growth rates as input size n increases

Links “efficiently computable” with polynomial time

Sorting/searching/graph algorithms analyzed for worst/average time; space becomes formal

Establishes NP-completeness and reductions; “hardness” becomes central

Many important problems shown NP-complete; major practical relevance

P, NP, co-NP, PSPACE; completeness, reductions, hierarchies become standard toolkit

RSA and related schemes rely on hardness assumptions (e.g., factoring)

Randomized algorithms; BPP/RP; expected time and error probability enter complexity

Separates worst-case hardness from typical performance; motivates average-case complexity

Limits approximability unless P=NP; links verification structure to approximation

Complexity in terms of n and parameter k; FPT vs W[1]-hardness lens

Measures I/O operations and cache misses; bottlenecks beyond CPU steps

Passes, memory footprint, update time for massive data streams

Work/span, communication complexity, network models for large-scale computation

Training/inference cost, sample complexity, optimization complexity; accuracy vs budget tradeoffs

Precise bounds (near-quadratic vs near-linear); conditional lower bounds (e.g., SETH)

Quantum models (BQP, etc.) and algorithms (simulation, factoring) reshape “efficient” under new hardware

Energy complexity complements time/space as real-world constraints

Describes how required computational resources grow with input size n

Main resources: time complexity (operations) and space complexity (memory)

Uses growth-rate notation to ignore constants/lower-order terms for large n

Big-O: upper bound (worst-case growth rate)

Big-Ω: lower bound

Big-Θ: tight bound

Worst-case complexity: maximum resources over all inputs of size n

Average-case complexity: expected resources under an input distribution

Amortized complexity: average per operation over a sequence (e.g., dynamic arrays)

Expected complexity: expectation over algorithm randomness

O(1), O(log n), O(n), O(n log n), O(n²), O(n³), O(2ⁿ), O(n!)

Predicts scalability, guides algorithm choice/design, explains feasibility (polynomial vs exponential)

Asymptotics can hide large constants; performance depends on hardware, memory hierarchy, input structure, implementation details