Algorithms flashcards, generated for you.

A step-by-step procedure to solve a problem or compute a result, with a defined input, output, and finite number of operations.

The number of elementary operations an algorithm performs as a function of input size n, expressed in Big-O notation (worst-case, average-case, or best-case).

The total amount of memory (RAM) an algorithm uses relative to input size n, including auxiliary space for variables, recursion stacks, and data structures.

O(n) is linear—doubling input roughly doubles operations. O(n²) is quadratic—doubling input roughly quadruples operations. O(n²) degrades much faster for large inputs.

Often optimizing for faster runtime requires more memory, and vice versa. Example: hash tables are O(1) lookup (space cost) vs. sorted arrays that are O(log n) but use less memory.

An algorithm that makes locally optimal choices at each step, hoping to find a global optimum. Works only when the problem has the 'greedy choice property' (local optimality guarantees global optimality), like Dijkstra's or activity selection.

DP solves overlapping subproblems by storing results (memoization/tabulation) and building up solutions; it guarantees correctness for problems with optimal substructure. Greedy doesn't revisit subproblems and can fail on non-greedy-choice problems (e.g., coin change).

A paradigm that breaks a problem into independent subproblems, solves each recursively, then combines results. Example: merge sort divides array in half, sorts each half, merges them. Time: O(n log n).

Hash table if you need O(1) average lookup/insert and don't need ordered traversal or range queries. Sorted array if you need O(log n) search, order, or range scans—and can afford O(n) insertion.

The average cost per operation over a sequence of operations, not per single operation. Example: dynamic array append is O(1) amortized even though occasional resizing is O(n), because resizing happens rarely. Matters for real performance in tight loops.