Algorithm patterns: all 52, and which one a problem needs

A read pointer scans ahead while a write pointer trails behind it. The write pointer moves only when a value is worth keeping.

Grow the window from the right, and shrink it from the left when the condition breaks. Neither end ever moves backwards.

Record the change at each index instead of the value. A range update costs two writes, and one final pass rebuilds everything.

Look at the middle of a sorted range and throw away the half that cannot hold the answer. Repeat until one item is left.

A sorted array that was cut and swapped still has one sorted half at every step. Find that half, then pick a side to keep.

The thing you search here is the range of every possible answer. A yes-or-no test decides which half of it to throw away.

Cut the array in two, sort each part, then put them back together. Merge sort cuts by position, quick sort cuts by value.

Counting and radix sort never compare two values. They read the key itself, which beats n log n when the range is small.

A comparator answers exactly one question: which of these two items comes first. The sort algorithm handles everything else.

Turn each interval into a start event and an end event. Then sort all the events by position and walk them with a counter.

One pointer moves a single step at a time while the other moves two steps. The gap between them exposes cycles and midpoints.

Build the answer on a dummy node and take from the front of each list. That dummy removes every empty-list special case.

Keep the stack's values increasing from bottom to top. Pop everything the new value beats, and each pop just found its answer.

A deque kept in order, so its front is always the window's maximum. Beaten values leave the back, expired ones the front.

Recursion that writes down every answer it computes. When the same argument comes back, the stored value is handed back.

A search tree keeps all the smaller values to the left and the larger ones to the right. Every lookup drops one whole side.

The lowest common ancestor is the deepest node that has both targets below it. One post-order pass over the tree finds it.

Write a tree out as one flat string, then rebuild it exactly. The markers for the missing children are what make it work.

Start a new walk at every node you have not seen yet. Every walk that actually starts marks out one more connected group.

Order the tasks so that every one of them comes after everything it depends on. Keep taking whichever node owes nothing.

Every element points at a parent, and walking up reaches a root that names its group. Two elements match when their roots match.

Settle the closest node not yet settled, then relax all of its edges. A heap keeps that node always one single read away.

Walk a graph using every one of its edges exactly once. Push a node the moment it gets stuck, then read the answer backwards.

Colour any one node, then colour each of its neighbours in the other colour. A conflict proves the graph is not bipartite.

The state here is a pair of positions, one in each of the two sequences. Every cell asks whether those two items match up.

The state is a range, and the transition picks the last move made inside it. The shorter ranges are always filled first.

Every node's answer is built out of the answers given by its own children. A single post-order pass computes all of them.

In a grid sorted both ways, one corner can only move in a single direction. Each comparison drops a whole row or column.

Search a grid by stepping into a neighbour and then stepping back out again. The cell stays marked while you are inside it.