A logbook for curious waters

Bubble sort

Compare neighbors and let large values travel to the right.

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

Bubble sort: the idea

Prerequisites: Arrays, comparisons, and swapping two items.

An array is an ordered collection of items. Bubble sort compares adjacent items and swaps them if the left value is larger. One complete pass places the largest remaining value at the right end. The next pass stops before that settled suffix. If a pass makes no swaps, the whole array is sorted.

Try it on the same input

Choose Already sorted, then compare Bubble with Selection. Bubble stops after a single pass with no swaps. Choose Reversed to watch repeated neighbor swaps.

Time, memory, and stability

n is the number of input items. Best O(n); average and worst O(n²). O(1) auxiliary space.

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

Repeated adjacent swaps make large unsorted inputs expensive. It is useful for learning local comparisons and early termination.

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