A space-time tradeoff is the recurring design decision between spending memory and spending computation. Many problems can be solved either by storing more data so that answers are available quickly, or by storing less and recomputing answers when they are needed. Choosing where to sit on that spectrum is one of the basic judgments in algorithm and system design.
The clearest examples come from storing results to avoid redoing work. Memoization and dynamic programming keep a table of already-computed subproblem answers so each is solved only once, trading memory for a large reduction in repeated computation. Caches, lookup tables, and database indexes follow the same pattern: they consume extra space to turn slow operations into fast lookups. MIT’s 6.006 Introduction to Algorithms organizes much of its material around exactly these structures, covering hash tables, heaps, balanced search trees, and dynamic programming as ways of trading space and structure for speed.
The tradeoff runs in the other direction too. An algorithm can be designed to use very little extra memory by recomputing values on demand or by overwriting its input in place, accepting more work or more complexity in exchange for a smaller footprint. On a memory-constrained device this can be the deciding factor.
There is no single correct point on the curve; the right balance depends on how scarce memory is, how expensive the computation is, and how often the operation runs. Recognizing that almost every performance choice is some form of space-time tradeoff is a useful lens for designing and tuning programs.