Algorithms, explained simply

Swap neighbours until the biggest value floats to the end.

Find the smallest, put it in front, repeat.

Build a sorted run one card at a time, like a poker hand.

Split in half, sort each half, merge the two back together.

Pick a pivot, split around it, recurse on both sides.

Turn the array into a heap, then pop the max n times.

Count how many of each value, then rewrite the array. No comparisons.

Sort by last digit, then next digit, until you run out of digits.

Check every item until you find it. Simple and always works.

Halve a sorted range each step - 1M items in 20 checks.

Walk two cursors toward each other instead of nesting loops.

Slide a range across the array, adding one end and dropping the other.

Explore ring by ring with a queue. Finds the fewest-hops path.

Go as deep as possible, then back up and try the next branch.

Cheapest path first, using a priority queue. No negative weights.

Relax every edge V−1 times. Slower than Dijkstra, but handles negatives.

Order tasks so every dependency comes before what needs it.

Track which items are connected, in near-constant time.

Sort the edges, add the cheap ones that don't make a cycle.

Pre-order, in-order, post-order - same walk, three moments to visit.

Read a tree row by row, top to bottom, with a queue.

Smaller left, bigger right - insert, find and delete in O(log n).

One node per character - the data structure behind autocomplete.

The clearest example of turning O(2ⁿ) into O(n) by remembering.

Largest sum of any run of numbers, in a single pass.

Fit the most value into a fixed bag - take an item or leave it.

The grid behind every diff tool you've ever used.

Fewest coins for an amount - where greedy quietly fails.

Find a substring without ever re-reading a character.

Place, recurse, and undo when it fails - backtracking in one picture.