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:
[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)
- Loop from the start of the array to the end.
- Compare each pair of adjacent elements.
- Swap them if they are in the wrong order.
- After each full pass, the largest unsorted element is placed correctly.
- 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.
About the Author
Latest tech news and coding tips.
