Bubble Sort (original) (raw)

Last Updated : 2 Jun, 2026

Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not efficient for large data sets as its average and worst-case time complexity are quite high.

Sorts the array using multiple passes. After the first pass, the maximum goes to end (its correct position). Same way, after second pass, the second largest goes to second last position and so on.
In every pass, process only those that have already not moved to correct position. After k passes, the largest k must have been moved to the last k positions.
In a pass, we consider remaining elements and compare all adjacent and swap if larger element is before a smaller element. If we keep doing this, we get the largest (among the remaining elements) at its correct position.

Below is the implementation of the bubble sort. It can be optimized by stopping the algorithm if the inner loop didn't cause any swap.

Try It Yourself

C++ `

#include <bits/stdc++.h> using namespace std;

// An optimized version of Bubble Sort void bubbleSort(vector& arr) { int n = arr.size(); bool swapped;

for (int i = 0; i < n - 1; i++) {
    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 no two elements were swapped, then break
    if (!swapped)
        break;
}

}

// Function to print a vector void printVector(const vector& arr) { for (int num : arr) cout << " " << num; }

int main() { vector arr = { 64, 34, 25, 12, 22, 11, 90 }; bubbleSort(arr); cout << "Sorted array: \n"; printVector(arr); return 0; }

C

// Optimized implementation of Bubble sort #include <stdbool.h> #include <stdio.h>

void swap(int* xp, int* yp){ int temp = *xp; *xp = *yp; *yp = temp; }

// An optimized version of Bubble Sort void bubbleSort(int arr[], int n){ int i, j; bool swapped; for (i = 0; i < n - 1; i++) { swapped = false; for (j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { swap(&arr[j], &arr[j + 1]); swapped = true; } }

    // If no two elements were swapped by inner loop,
    // then break
    if (swapped == false)
        break;
}

}

// Function to print an array void printArray(int arr[], int size){ int i; for (i = 0; i < size; i++) printf("%d ", arr[i]); }

int main(){ int arr[] = { 64, 34, 25, 12, 22, 11, 90 }; int n = sizeof(arr) / sizeof(arr[0]); bubbleSort(arr, n); printf("Sorted array: \n"); printArray(arr, n); return 0; }

Java

// Optimized java implementation of Bubble sort import java.io.*;

class GFG {

// An optimized version of Bubble Sort
static void bubbleSort(int arr[], int n){
    int i, j, temp;
    boolean swapped;
    for (i = 0; i < n - 1; i++) {
        swapped = false;
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                
                // Swap arr[j] and arr[j+1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }

        // If no two elements were
        // swapped by inner loop, then break
        if (swapped == false)
            break;
    }
}

// Function to print an array
static void printArray(int arr[], int size){
    int i;
    for (i = 0; i < size; i++)
        System.out.print(arr[i] + " ");
    System.out.println();
}

// Driver program
public static void main(String args[]){
    int arr[] = { 64, 34, 25, 12, 22, 11, 90 };
    int n = arr.length;
    bubbleSort(arr, n);
    System.out.println("Sorted array: ");
    printArray(arr, n);
}

}

Python

Optimized Python program for implementation of Bubble Sort

def bubbleSort(arr): n = len(arr)

# Traverse through all array elements
for i in range(n):
    swapped = False

    # Last i elements are already in place
    for j in range(0, n-i-1):

        # Traverse the array from 0 to n-i-1
        # Swap if the element found is greater
        # than the next element
        if arr[j] > arr[j+1]:
            arr[j], arr[j+1] = arr[j+1], arr[j]
            swapped = True
    if (swapped == False):
        break

Driver code to test above

if name == "main": arr = [64, 34, 25, 12, 22, 11, 90]

bubbleSort(arr)

print("Sorted array:")
for i in range(len(arr)):
    print("%d" % arr[i], end=" ")

C#

// Optimized C# implementation of Bubble sort using System;

class GFG {

// An optimized version of Bubble Sort
static void bubbleSort(int[] arr, int n){
    int i, j, temp;
    bool swapped;
    for (i = 0; i < n - 1; i++) {
        swapped = false;
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                
                // Swap arr[j] and arr[j+1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }

        // If no two elements were
        // swapped by inner loop, then break
        if (swapped == false)
            break;
    }
}

// Function to print an array
static void printArray(int[] arr, int size){
    int i;
    for (i = 0; i < size; i++)
        Console.Write(arr[i] + " ");
    Console.WriteLine();
}

// Driver method
public static void Main(){
    int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
    int n = arr.Length;
    bubbleSort(arr, n);
    Console.WriteLine("Sorted array:");
    printArray(arr, n);
}

}

JavaScript

// An optimized version of Bubble Sort function bubbleSort(arr) { const n = arr.length; let swapped;

for (let i = 0; i < n - 1; i++) {
    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 no two elements were swapped, then break
    if (!swapped)
        break;
}

}

const arr = [64, 34, 25, 12, 22, 11, 90]; bubbleSort(arr); console.log('Sorted array:') console.log(arr);

PHP

n=sizeof(n = sizeof(n=sizeof(arr); // Traverse through all array elements for($i = 0; i<i < i<n; $i++) { $swapped = False; // Last i elements are already // in place for ($j = 0; j<j < j<n - i−1;i - 1; i−1;j++) { // Traverse the array from 0 to // n-i-1. Swap if the element // found is greater than the // next element if ($arr[$j] > arr[arr[arr[j+1]) { t=t = t=arr[$j]; arr[arr[arr[j] = arr[arr[arr[j+1]; arr[arr[arr[j+1] = $t; $swapped = True; } } // If no two elements were swapped // by inner loop, then break if ($swapped == False) break; } } // Driver code $arr = array(64, 34, 25, 12, 22, 11, 90); len=sizeof(len = sizeof(len=sizeof(arr); bubbleSort($arr); echo "Sorted array: \n"; for($i = 0; i<i < i<len; $i++) echo arr[arr[arr[i]." "; // This code is contributed by ChitraNayal. ?>

Complexity Analysis of Bubble Sort:

**Time Complexity: O(n2)
**Auxiliary Space: O(1)

Please refer Complexity Analysis of Bubble Sort for details.

**Advantages of Bubble Sort

Bubble sort is easy to understand and implement.
It does not require any additional memory space.
It is a stable sorting algorithm, meaning that elements with the same key value maintain their relative order in the sorted output.

**Disadvantages of Bubble Sort

Bubble sort has a time complexity of O(n2) which makes it very slow for large data sets.
Bubble sort has almost no or limited real world applications. It is mostly used in academics to teach different ways of sorting.

**Related Articles