Bubble Sort Visualization — Step by Step

Step 1: Sweep and swap neighbours

Bubble Sort only ever looks at two elements at a time: a value and its right-hand neighbour. Take [7, 3, 9, 2]. The first pass compares 7 and 3 — out of order, swap — giving [3, 7, 9, 2]. Next it compares 7 and 9: already fine, no swap. Then 9 and 2: swap, giving [3, 7, 2, 9]. Notice that 9, the largest value, was picked up mid-pass and carried all the way to the last index. That drift of the biggest element toward the end is the "bubble" the algorithm is named for.

Step 2: Repeat, but stop one element earlier

After pass one, the largest value is guaranteed to sit at the last index — no later comparison can move it. So pass two only needs to sweep [3, 7, 2]: compare 3 and 7 (fine), then 7 and 2 (swap) → [3, 2, 7, 9]. Pass three sweeps just [3, 2] and swaps to [2, 3, 7, 9]. Each pass locks one more element into the tail, which is why the inner loop bound shrinks by one every iteration (n - i - 1 in the code below).

Why the sorted region grows from the right

The invariant that makes Bubble Sort correct: during a pass, whenever the sweep reaches position j, it is carrying the largest value seen so far in that pass. Whatever is largest in the unsorted zone therefore always reaches the zone's right edge by the end of the pass. Small values are the opposite story — a small element moves at most one slot left per pass (these slow movers are sometimes called "turtles"), which is the intuition for why reverse-sorted input is the worst case: the smallest element needs n−1 full passes to crawl home.

The early exit: a free sortedness check

The one genuinely clever piece of Bubble Sort is the swapped flag. If a complete pass makes zero swaps, every neighbouring pair is in order — and if every neighbour is in order, the whole array is sorted, so the algorithm stops immediately. This gives Bubble Sort a best case of O(n) on already-sorted input: one verification pass and done. It also makes the algorithm *adaptive* — a nearly-sorted array finishes in a few passes rather than the full n−1.

Counting the cost

On random input there is no early exit to save you. Pass one makes n−1 comparisons, pass two makes n−2, down to 1 — a total of n(n−1)/2, which grows as n². Worse, every element travels to its final position one swap at a time, so an element that belongs 50 slots away costs 50 separate writes. That is the structural reason Quick Sort and Merge Sort win: their operations move elements long distances. You can race them and watch the gap open up.

JavaScript

function bubbleSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    let swapped = false;
    for (let j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        swapped = true;
      }
    }
    if (!swapped) break; // early exit: no swaps means sorted
  }
  return arr;
}

Python

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        swapped = False
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:  # early exit: no swaps means sorted
            break
    return arr

Java

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                swapped = true;
            }
        }
        if (!swapped) break; // early exit: no swaps means sorted
    }
}