Algorithm visualizations

The simplest sort — watch the largest value bubble to the end each pass.

Build the sorted part one card at a time — the way you sort a hand of cards.

Find the smallest remaining value each pass and swap it into place.

Split until single elements, then merge sorted halves back together — O(n log n), always.

Partition around a pivot, then recurse — the fastest sort in practice.

Halve the search space every step — find a value in a sorted array in O(log n).

Check every element until you find it — the baseline every other search beats.

Close in from both ends of a sorted array — O(n) instead of O(n²).

Reuse the previous window's answer instead of recomputing it.

Explore a graph level by level using a queue — shortest paths on unweighted graphs.

Go as deep as possible before backtracking — the recursion tree made visible.

Shortest paths on a weighted graph — always expand the closest unfinished node.

Order tasks so every dependency comes first — Kahn's algorithm with in-degrees.

An ordered tree where left < node < right — insert, search and traverse.

In-order, pre-order, post-order — where the visit sits in the recursion.

Range queries and point updates in O(log n) on an array-shaped tree.

Turn exponential recursion into linear time by caching subresults.

Take it or leave it — the DP table that defines the field.

How much two strings share, in order — the basis of diff.

Fewest coins for an amount — where greedy fails and DP works.

Merge disjoint sets and query connectivity almost in constant time.

Nodes connected by pointers — traversal and insertion made visible.

Last-in-first-out versus first-in-first-out, side by side.

Always pop the largest — a tree hiding inside an array.

Precompute once, then answer any range sum with a single subtraction.