Learn algorithms by watching them think

Bubble Sort

Adjacent elements swap their way to order — simple, visual, and famously slow.

Selection Sort

Scan for the minimum, lock it in, repeat — the fewest writes of any comparison sort.

Insertion Sort

Slide each new element into its place in the sorted prefix — the quadratic sort that production code actually uses.

Merge Sort

Split in half, sort each side, merge two sorted streams — guaranteed O(n log n), stable, and built for data that doesn't fit in memory.

Quick Sort

Pick a pivot, split around it, recurse — the cache-friendly in-place sort that most systems code is built on.

Heap Sort

Build a max-heap, then repeatedly pull the root to the back — guaranteed O(n log n) with O(1) memory.

Shell Sort

Insertion sort with a running start: sort far-apart elements first, then shrink the gap until one pass finishes the job.

Counting Sort

Don't compare — count. Tally each key, compute positions with prefix sums, and place every element exactly once.

Radix Sort

Sort digit by digit with a stable pass per position — linear-time sorting for fixed-width keys.

Bucket Sort

Scatter values into range-based buckets, sort each tiny bucket, and concatenate — linear time when data spreads evenly.

Tim Sort

The pragmatist's sort: detect the runs real data already has, insertion-sort the small stuff, merge the rest — the algorithm behind Python, Java, and V8.

Linear Search

Walk the array front to back and compare every element — zero preconditions, zero setup, and unbeatable when the data is small or unsorted.

Binary Search

Halve the search space on every comparison — a sorted array of a billion elements falls in about 30 probes.

Jump Search

Leap through a sorted array in √n-sized strides, then walk back linearly inside the one block that can hold the target.

Exponential Search

Double a probe index until you overshoot, then binary-search the last doubling — O(log i) where i is the target's position, not the array's size.

Interpolation Search

Instead of always probing the middle, estimate where the target should be from its value — O(log log n) on uniformly distributed keys.

Hash Lookup

Compute where the key lives instead of searching for it — expected O(1) no matter how large the table grows.

Binary Search Tree Search

Binary search made dynamic — one ordering comparison per level steers you left or right, and the structure absorbs inserts and deletes that would cripple a sorted array.

Trie Search

Search time depends on the length of the key, not how many keys you've stored — a dictionary of a million words answers in exactly as many steps as the word has letters.

Breadth-First Search (BFS)

Explore a graph in expanding rings from the start — the first time you reach a node is provably the shortest unweighted path to it.

Depth-First Search (DFS)

Commit to one path until it dead-ends, then backtrack — the traversal that turns recursion itself into a graph explorer.