A logbook for curious waters

Merge sort

Sort two halves, then weave their values into one ordered sequence.

Cyan: idle · Pink: inspected · Amber outline: pivot · Green: final position

Labels such as #3 record original input positions. Equal values can have different identities. A highlighted range is currently being processed; a sorted prefix can still move later.

Comparisons
0
Swaps
0
Array writes
0
Recursion depth
0

Current array

IndexValueOriginal position

Sorting pseudocode

Highlighted lines correspond to recorded operations. Counters measure comparisons between item values and writes to the main array; copying the merge buffer is excluded.

Read the executable JavaScript

Merge sort: the idea

Prerequisites: Arrays, recursion, and merging two sorted sequences.

Recursion means solving a smaller instance of the same problem. Merge sort splits a range into two halves, recursively sorts each half, then merges them. The merge copies both halves into temporary storage and repeatedly writes the smaller front item back into the array. If the values are equal, it takes the left item first to preserve original order.

Try it on the same input

Watch the active range shrink to single items, then grow as sorted halves merge. The buffer shows the two copied halves and marks consumed items. During a write, the main array can temporarily repeat an identity; unwritten items remain safe in the buffer.

Time, memory, and stability

n is the number of input items. Best, average, and worst O(n log n) for this version. O(n) auxiliary space, including temporary merge storage; recursion depth O(log n).

A stable sort preserves the original order of items whose values are equal. This implementation is stable. Identity labels record each item’s initial position. An unstable algorithm can preserve equal-item order on a particular input; it makes no guarantee for all inputs.

These bounds describe the sorting algorithm itself. The visualization saves a copy of the array at every operation for reversible playback, so recording uses additional time and memory. Its input size is capped at 24 items.

When to use it—and what to watch

Predictable performance and stability come with extra storage. The playback records each operation, so its memory use exceeds the algorithm’s working memory.

Reading the display

Comparisons count tests between item values. A swap writes two array positions; a merge write updates one. The counters exclude copying merge buffers, index tests, and playback work, so they are teaching measurements rather than elapsed-time benchmarks. Green marks final positions; a highlighted range indicates current work. For recursive algorithms, depth counts the active call levels.

Continue exploring

Sources and further reading