See how every algorithm actually works

Watch the growth curves separate as n climbs.

Why indexing is O(1) and inserting at the front is not.

Push values and watch the capacity double.

Watch fib(n) build an exponential tree, then memoise it away.

Three lines of recursion, 2ⁿ − 1 provably optimal moves.

Set, clear, toggle - and the two identities worth memorising.

Repeatedly swap neighbours until nothing moves.

Find the minimum, move it to the front, repeat.

How you sort a hand of cards.

Insertion sort that can move things a long way.

Split to single elements, then merge back in order.

Partition around a pivot, then recurse on both halves.

Build a heap in the array, then extract the maximum n times.

Sorting with zero comparisons.

Sort by the last digit, then the next, and it comes out ordered.

Scatter by value range, sort each bucket, concatenate.

Check every position until you find it.

Halve the search space with every comparison.

The half-open variant that handles duplicates.

Skip in blocks of √n, then scan backwards.

Double the reach until you overshoot, then binary search.

Guess where the value should be, like using a phone book.

The interview version: search a predicate, not an array.

O(1) at the head, a walk for everything else.

A back pointer buys O(1) deletion.

The tail points back at the head.

Three pointers, and the order of four lines is everything.

Tortoise and hare, in O(1) memory.

Last in, first out - and both ends are O(1).

First in, first out - and why list.pop(0) is a bug.

A queue open at both ends.

Modulo turns a fixed array into an endless stream.

Next greater element in one linear pass.

A hash map and a doubly linked list, covering each other's weakness.

Collisions share a bucket, and load factor is everything.

No chains - probe for the next free slot.

Why one insert in a thousand costs O(n).

One comparison eliminates a whole row of the brute force.

Two operations replace k additions.

Grow right, shrink left, never move backwards.

Precompute once, answer every range query in O(1).

Range updates in O(1), materialised once at the end.

One decision, repeated n times.

Sort 0s, 1s and 2s in a single pass.

Pre, in, post and level order - recursive and iterative.

Insert, search and the three cases of deletion.

Four rotation cases that refuse to let the tree lean.

An array pretending to be a tree.

The path is the key.

Range queries and point updates, both O(log n).

Prefix sums in one array, driven by the lowest set bit.

The same graph, three ways, with very different costs.

Expands in rings, so it finds shortest paths.

A stack instead of a queue - that is the only difference.

Kahn's algorithm, with cycle detection for free.

Settle the closest unvisited node, then relax its edges.

Slower than Dijkstra, but it survives negative weights.

All pairs, three nested loops, one line of logic.

Path compression and union by rank, together.

Cheapest edge first, skipping anything that closes a cycle.

Dijkstra with one line changed.

Paint a maze and watch three algorithms solve it differently.

Slide one place right and start over.

The text pointer never moves backwards.

A rolling hash, and why verification is not optional.

How far does the prefix repeat at every position?

Longest palindromic substring in O(n).

Switch pruning off and watch the search explode.

Try, recurse, undo - plus one ordering trick.

Swap in place, recurse, swap back.

One binary decision per element - and a bitmask does the same job.

Watch corridors light up and go dark again.

Earliest finish time - and two plausible rules that fail.

Densest first, and split the last item.

Merge the two rarest symbols, repeatedly.

Greedy works for real currencies and fails for made-up ones.

One subproblem per amount, and no first choice can trap it.

Take it or leave it, at every capacity.

Match means diagonal; mismatch means the better of two.

Three neighbours, three edits, one minimum.

The O(n²) table, and the O(n log n) trick that replaces it.

Two choices per house, and the table collapses to two variables.

Counting problems reduce to a sum of two neighbours.