CodeCookbook

Nine strategies applied in order: tally, gallop, cut at the golden ratio, consult three voices, roll the die, divide into three, recurse the small.

Reads the data before sorting: counting sort for integer ranges, insertion sort for tiny or nearly-sorted inputs, introsort with heapsort fallback otherwise.

Quicksort with a safety net: if recursion depth exceeds 2·log₂n, it falls back to heapsort. Small subarrays finish with insertion sort. The basis of std::sort.

Compares adjacent pairs and swaps them if out of order. Each pass settles the largest remaining element.

Finds the minimum of the unsorted region and swaps it to the sorted boundary. O(n) swaps total.

Inserts each element into its correct spot in the already-sorted prefix. Fast on nearly-sorted data.

Recursively divides in half, sorts each half, then merges. Guaranteed O(n log n) in all cases.

Picks a pivot, partitions around it, and recurses on both sides. O(n log n) average; O(n²) worst case.

Builds a max-heap, then repeatedly extracts the max to produce sorted output in-place.

Insertion sort over a shrinking gap — long-range swaps first, fine-tuning last.

Tallies occurrences of each integer and reconstructs the array. Requires a bounded key range.

Sorts digit by digit, least to most significant, using counting sort at each position.

Scatters elements into buckets, sorts each bucket with insertion sort, then concatenates.

Detects natural runs, extends short ones with insertion sort, then merges via galloping mode. Python's and Java's built-in sort.

Bidirectional bubble sort — forward pass pushes the max right, backward pass pushes the min left. Faster on partially-sorted data.

Eliminates turtles (small values near the end) by comparing elements far apart. Shrinks the gap by factor 1.3 each pass.

A single pointer advances if neighbors are in order, or swaps and retreats. The simplest possible sorting algorithm.

Sorts by prefix reversals only — like flipping stacks of pancakes. Each round places the next-largest element using at most 2 flips.

Writes each element exactly once by tracing permutation cycles. Optimal when array writes are expensive.

Alternates between odd-indexed and even-indexed adjacent swaps. Parallelizes naturally — each phase can run simultaneously.

Last-In-First-Out. Push and pop from the top of the stack.

First-In-First-Out. Enqueue at back, dequeue from the front.

Double-ended queue. Push and pop from both front and back.

Nodes connected by pointers. Insert, delete, and traverse.

Min-heap tree. Insert and extract-min with percolate operations.

Hash function maps keys to buckets. Separate chaining for collisions.

Binary Search Tree. Insert, search, delete, and traversal animations.

Undirected graph with BFS and DFS traversal step-by-step.

Self-balancing BST. Every insert/delete triggers LL, RR, LR, or RL rotations to keep balance factors in {−1, 0, 1}.

Self-balancing BST with color bits. Uses recoloring and rotations to maintain 5 invariants, guaranteeing O(log n) height.

Prefix tree that stores strings character by character. O(m) insert and search where m is the word length.

Range-query tree. O(log n) range-sum queries and point updates with step-by-step traversal animations.

All algorithms and data structures at a glance — sort by time, space, stability. Filter, print, or bookmark for interview prep.

See an algorithm name, guess the complexity, track your score. Covers all sorting algorithms and data structures.

Stability? Memory constraints? Nearly sorted data? Answer a few questions and get a tailored recommendation with reasoning.

Select a complexity class, enter n, and see estimated milliseconds. Compare all classes side by side in one reference table.

Click to draw walls, drag to set start/end, pick an algorithm, and watch it find a path step by step.

Each algorithm gets its own oscillator type and pitch range. Start them all together and listen to the chaos resolve into order.

40+ questions, streaks, timer, and a local high score. See an algorithm, guess its Big-O. Covers sorting, data structures, searching, and graph algorithms.

See how bitonic sort uses a fixed network of comparators to sort in O(log² n) parallel stages with no branching.