Bubble Sort: Mechanism, Complexity Analysis & Interactive Visualizer

Bubble Sort

The classic teaching algorithm: repeatedly walk the array, swap any out-of-order neighbors, and let the largest element bubble to the top of each pass.

How it works

Bubble Sort makes repeated left-to-right passes over the array. On each pass it compares every adjacent pair of elements and swaps them if they are in the wrong order. Each full pass guarantees that one more of the largest unsorted values has reached its final position at the end of the array, like a bubble of air rising to the surface of water.

1. Start at index 0.
2. Compare arr[i] with arr[i+1].
3. If they are out of order, swap them.
4. Move one step right and repeat until you reach the end of the unsorted portion.
5. After each pass, the last position of the unsorted portion is fixed; shrink the working range and repeat until no swaps are possible.

Complexity

Interactive visualization

Pseudocode

procedure bubbleSort(A):
  n ← length(A)
  for i from 0 to n − 2:
    for j from 0 to n − i − 2:
      if A[j] > A[j+1]:
        swap A[j], A[j+1]

JavaScript implementation

function bubbleSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    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]];
      }
    }
  }
  return arr;
}

Pros and cons

When (not) to use it

• Teach the idea of comparison-based sorting. It is the canonical first algorithm.
• Tiny arrays (n < 10). Performance differences disappear, and the simplicity is a feature.
• Never use it for real workloads. Insertion sort dominates it on small inputs, and any O(n log n) sort dominates it on large ones.