Bubble Sort Algorithm

Bubble Sort is one of the simplest sorting algorithms in computer science. Although it’s not the fastest or most efficient, it is often the first algorithm taught because it helps beginners understand fundamental ideas like comparison, swapping, and iteration.

Let’s break it down step-by-step.

Learn how to write computer programs

What Is Bubble Sort?

Bubble Sort is a comparison-based sorting algorithm that repeatedly goes through a list, compares adjacent elements, and swaps them if they are in the wrong order.
This process continues until the entire list is sorted.

It gets its name from the way larger elements “bubble” to the top (end of the list), and smaller elements sink to the bottom.

How Bubble Sort Works (Concept)

Imagine you have a row of numbers:

Learn programming online

[5, 1, 4, 2, 8]

Bubble Sort will:

Pass 1

Compare each pair:

• Compare 5 and 1 → swap → [1, 5, 4, 2, 8]
• Compare 5 and 4 → swap → [1, 4, 5, 2, 8]
• Compare 5 and 2 → swap → [1, 4, 2, 5, 8]
• Compare 5 and 8 → no swap

Largest element (8) moves to the end.

Pass 2

Repeat the process for the remaining elements:

• Compare 1 and 4 → ok
• Compare 4 and 2 → swap → [1, 2, 4, 5, 8]
• Compare 4 and 5 → ok

Next-largest element (5) is now correctly placed.

Bubble Sort keeps doing this until no more swaps are needed.

Bubble Sort Algorithm (Step-by-Step)

1. Loop from the start of the array to the end.
2. Compare each pair of adjacent elements.
3. Swap them if they are in the wrong order.
4. After each full pass, the largest unsorted element is placed correctly.
5. Stop when a full pass occurs with zero swaps.

Bubble Sort in Pseudocode

repeat
    swapped = false
    for i = 0 to n-2
        if array[i] > array[i+1]
            swap(array[i], array[i+1])
            swapped = true
    end for
until swapped == false

The swapped flag is used to optimize the algorithm so it stops early when the list is already sorted.

Bubble Sort — JavaScript Implementation

function bubbleSort(arr) {
  let swapped;

  do {
    swapped = false;
    for (let i = 0; i < arr.length - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        // Swap
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
        swapped = true;
      }
    }
  } while (swapped);

  return arr;
}

console.log(bubbleSort([5, 1, 4, 2, 8]));

Time and Space Complexity

Case	Time Complexity
Best Case (already sorted)	O(n)
Average Case	O(n²)
Worst Case	O(n²)
Space Complexity	O(1) (in-place)

Why O(n²)?

Because for each of the n elements, we might compare it with almost n others.

Where Bubble Sort Is Useful

Even though it’s not efficient for large data, Bubble Sort is useful when:

• You want to teach sorting concepts to beginners
• Working with very small lists
• You need a simple and easy-to-understand algorithm
• You want to detect whether a list is already sorted (early stopping)

Limitations of Bubble Sort

• Extremely slow on large lists
• Requires many comparisons
• Inefficient compared to modern algorithms like QuickSort, MergeSort, or HeapSort

Advantages

• Very simple to implement
• Easy to visualize
• Works in-place (constant memory usage)
• Good for educational purposes

Summary

Bubble Sort is the simplest sorting algorithm that repeatedly compares and swaps adjacent elements until the list is ordered. Though not efficient for large datasets, it is a perfect introduction to sorting concepts, complexity analysis, and algorithm design.