Bubble Sort — VizionX (CTC)

Bubble Sort is one of the simplest sorting algorithms: it repeatedly steps through the list, compares adjacent elements, and swaps them if they are out of order. Its name comes from how larger elements "bubble" to the end of the list over multiple iterations.

Bubble Sort is easy to understand and implement, making it a staple in algorithm education. It excels at sorting small or nearly-sorted datasets due to its adaptive nature—if a pass results in no swaps, the list is already sorted and the process can terminate early.

However, Bubble Sort is inefficient for large, random datasets. Its time complexity in the average and worst cases is quadratic—O(n²)—making it significantly slower than more advanced algorithms like QuickSort or Merge Sort.

Time Complexity

Case	Time Complexity
Best (already sorted with optimization)	O(n)
Average	O(n²)
Worst	O(n²)

Code Examples

Choose Language:

# Python - optimized bubble sort
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break
    return arr

// C++ - optimized bubble sort
#include <vector>
using namespace std;

void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n; i++) {
        bool swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

// Java - optimized bubble sort
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            boolean swapped = false;
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) break;
        }
    }
}

// JavaScript - optimized bubble sort
function bubbleSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n; 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;
  }
  return arr;
}