Bubble Sort

How it works, step by step

1. 1

   Start at the left side. Look at the first two values.

2. 2

   Is the left value bigger than the right one? Swap them. If not, do nothing.

3. 3

   Move one step to the right. Compare the next pair. Keep going to the end of the array.

4. 4

   That was one pass. After it, the biggest value is in the last slot - nothing could stop it on the way there.

5. 5

   Do another pass. The end of the array is already sorted, so each new pass can stop one step earlier.

6. 6

   If a full pass makes zero swaps, the array is already sorted. Stop right away.

The code, in JavaScript

function bubbleSort(arr) {
  const a = [...arr];              // copy, so we don't change the input

  for (let i = 0; i < a.length - 1; i++) {
    for (let j = 0; j < a.length - 1; j++) {
      if (a[j] > a[j + 1]) {
        // wrong order → swap the two values
        const temp = a[j];
        a[j] = a[j + 1];
        a[j + 1] = temp;
      }
    }
  }

  return a;
}

bubbleSort([5, 1, 4, 2]);          // → [1, 2, 4, 5]

Dry run: sorting [5, 1, 4, 2]

The same steps the visualizer plays, written as a table. Generated by running the real algorithm - not written by hand.

• The O(n) best case needs the `swapped` flag. The simple version is O(n²) even on a sorted array. People quote the fast number but write the slow version.
• Forgetting `- i` in the inner loop still sorts correctly - but it re-checks the sorted tail every pass, which is about double the work.
• `[a[j], a[j+1]] = [a[j+1], a[j]]` looks nice, but it creates a small throw-away array on every swap. In a hot loop, a plain temp variable is faster.
• A common JS trap (not only for bubble sort): `[10, 9, 1].sort()` gives `[1, 10, 9]`. The default sort compares values as strings. Always pass `(a, b) => a - b` for numbers.

Bubble Sort vs. its closest relatives