Bubble Sort Algorithm


14 Jul, 2022

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 suitable for large data sets as its average and worst-case time complexity is quite high.
Consider an array arr[] = {5, 1, 4, 2, 8}
First Pass: 
Bubble sort starts with very first two elements, comparing them to check which one is greater.

( 5 1 4 2 8 ) –> ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1. 
( 1 5 4 2 8 ) –>  ( 1 4 5 2 8 ), Swap since 5 > 4 
( 1 4 5 2 8 ) –>  ( 1 4 2 5 8 ), Swap since 5 > 2 
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.


( 5 1 4 2 8 ) –> ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1. 
( 1 5 4 2 8 ) –>  ( 1 4 5 2 8 ), Swap since 5 > 4 
( 1 4 5 2 8 ) –>  ( 1 4 2 5 8 ), Swap since 5 > 2 
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.
Second Pass: 
Now, during second iteration it should look like this:

( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ) 
( 1 4 2 5 8 ) –> ( 1 2 4 5 8 ), Swap since 4 > 2 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –>  ( 1 2 4 5 8 ) 


( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ) 
( 1 4 2 5 8 ) –> ( 1 2 4 5 8 ), Swap since 4 > 2 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –>  ( 1 2 4 5 8 ) 
Third Pass: 
Now, the array is already sorted, but our algorithm does not know if it is completed.
The algorithm needs one whole pass without any swap to know it is sorted.

( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 


( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 ) 
Illustration:
Following are the implementations of Bubble Sort. 
C++
C
Java
Python3
C#
PHP
Javascript
 

 
 










// C++ program for implementation  
// of Bubble sort 
#include <bits/stdc++.h> 
using namespace std; 
  
// A function to implement bubble sort 
void bubbleSort(int arr[], int n) 
{ 
    int i, j; 
    for (i = 0; i < n - 1; i++) 
  
        // Last i elements are already  
        // in place 
        for (j = 0; j < n - i - 1; j++) 
            if (arr[j] > arr[j + 1]) 
                swap(arr[j], arr[j + 1]); 
} 
  
// Function to print an array  
void printArray(int arr[], int size) 
{ 
    int i; 
    for (i = 0; i < size; i++) 
        cout << arr[i] << " "; 
    cout << endl; 
} 
  
// Driver code 
int main() 
{ 
    int arr[] = { 5, 1, 4, 2, 8}; 
    int N = sizeof(arr) / sizeof(arr[0]); 
    bubbleSort(arr, N); 
    cout << "Sorted array: \n"; 
    printArray(arr, N); 
    return 0; 
} 
// This code is contributed by rathbhupendra






 

 
 










// C program for implementation of Bubble sort 
#include <stdio.h> 
  
void swap(int* xp, int* yp) 
{ 
    int temp = *xp; 
    *xp = *yp; 
    *yp = temp; 
} 
  
// A function to implement bubble sort 
void bubbleSort(int arr[], int n) 
{ 
    int i, j; 
    for (i = 0; i < n - 1; i++) 
  
        // Last i elements are already in place 
        for (j = 0; j < n - i - 1; j++) 
            if (arr[j] > arr[j + 1]) 
                swap(&arr[j], &arr[j + 1]); 
} 
  
/* Function to print an array */
void printArray(int arr[], int size) 
{ 
    int i; 
    for (i = 0; i < size; i++) 
        printf("%d ", arr[i]); 
    printf("\n"); 
} 
  
// Driver program to test above functions 
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 program for implementation of Bubble Sort 
class BubbleSort { 
    void bubbleSort(int arr[]) 
    { 
        int n = arr.length; 
        for (int i = 0; i < n - 1; i++) 
            for (int j = 0; j < n - i - 1; j++) 
                if (arr[j] > arr[j + 1]) { 
                    // swap arr[j+1] and arr[j] 
                    int temp = arr[j]; 
                    arr[j] = arr[j + 1]; 
                    arr[j + 1] = temp; 
                } 
    } 
  
    /* Prints the array */
    void printArray(int arr[]) 
    { 
        int n = arr.length; 
        for (int i = 0; i < n; ++i) 
            System.out.print(arr[i] + " "); 
        System.out.println(); 
    } 
  
    // Driver method to test above 
    public static void main(String args[]) 
    { 
        BubbleSort ob = new BubbleSort(); 
        int arr[] = { 64, 34, 25, 12, 22, 11, 90 }; 
        ob.bubbleSort(arr); 
        System.out.println("Sorted array"); 
        ob.printArray(arr); 
    } 
} 
/* This code is contributed by Rajat Mishra */






 

 
 










# Python program for implementation of Bubble Sort 
  
  
def bubbleSort(arr): 
    n = len(arr) 
  
    # Traverse through all array elements 
    for i in range(n): 
  
        # 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] 
  
  
# Driver code to test above 
arr = [64, 34, 25, 12, 22, 11, 90] 
  
bubbleSort(arr) 
  
print("Sorted array is:") 
for i in range(len(arr)): 
    print("%d" % arr[i], end=" ") 






 

 
 










// C# program for implementation 
// of Bubble Sort 
using System; 
  
class GFG { 
    static void bubbleSort(int[] arr) 
    { 
        int n = arr.Length; 
        for (int i = 0; i < n - 1; i++) 
            for (int j = 0; j < n - i - 1; j++) 
                if (arr[j] > arr[j + 1]) { 
                    // swap temp and arr[i] 
                    int temp = arr[j]; 
                    arr[j] = arr[j + 1]; 
                    arr[j + 1] = temp; 
                } 
    } 
  
    /* Prints the array */
    static void printArray(int[] arr) 
    { 
        int n = arr.Length; 
        for (int i = 0; i < n; ++i) 
            Console.Write(arr[i] + " "); 
        Console.WriteLine(); 
    } 
  
    // Driver method 
    public static void Main() 
    { 
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 }; 
        bubbleSort(arr); 
        Console.WriteLine("Sorted array"); 
        printArray(arr); 
    } 
} 
  
// This code is contributed by Sam007






 

 
 










<?php  
// PHP program for implementation  
// of Bubble Sort 
  
function bubbleSort(&$arr) 
{ 
    $n = sizeof($arr); 
  
    // Traverse through all array elements 
    for($i = 0; $i < $n; $i++)  
    { 
        // Last i elements are already in place 
        for ($j = 0; $j < $n - $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[$j+1]) 
            { 
                $t = $arr[$j]; 
                $arr[$j] = $arr[$j+1]; 
                $arr[$j+1] = $t; 
            } 
        } 
    } 
} 
  
// Driver code to test above 
$arr = array(64, 34, 25, 12, 22, 11, 90); 
  
$len = sizeof($arr); 
bubbleSort($arr); 
  
echo "Sorted array : \n"; 
  
for ($i = 0; $i < $len; $i++) 
    echo $arr[$i]." ";  
  
// This code is contributed by ChitraNayal. 
?>






 

 
 










<script> 
  
function swap(arr, xp, yp) 
{ 
    var temp = arr[xp]; 
    arr[xp] = arr[yp]; 
    arr[yp] = temp; 
} 
  
// An optimized version of Bubble Sort 
function bubbleSort( arr, n) 
{ 
var i, j; 
for (i = 0; i < n-1; i++) 
{ 
    for (j = 0; j < n-i-1; j++) 
    { 
        if (arr[j] > arr[j+1]) 
        { 
        swap(arr,j,j+1); 
          
        } 
    } 
  
} 
} 
  
/* Function to print an array */
function printArray(arr, size) 
{ 
    var i; 
    for (i=0; i < size; i++) 
        document.write(arr[i]+ " "); 
    document.write("\n"); 
} 
  
// Driver program to test above functions 
  var arr = [64, 34, 25, 12, 22, 11, 90]; 
    var n = 7; 
    document.write("UnSorted array: \n"); 
    printArray(arr, n); 
  
    bubbleSort(arr, n); 
    document.write("Sorted array: \n"); 
    printArray(arr, n); 
  
  
</script>






Sorted array: 
1 2 4 5 8 
The above function always runs O(n^2) time even if the array is sorted.
It can be optimized by stopping the algorithm if the inner loop didn’t cause any swap. 
Below is the implementation for the above approach: 
C++
C
Java
Python3
C#
PHP
Javascript
 

 
 










// Optimized implementation of Bubble sort 
#include <bits/stdc++.h> 
using namespace std; 
  
// 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++) 
        cout <<" "<< arr[i]; 
} 
  
// Driver program to test above functions 
int main() 
{ 
    int arr[] = {5, 3, 1, 9, 8, 2, 4, 7}; 
    int N = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, N); 
    cout <<"Sorted array: \n"; 
    printArray(arr, N); 
    return 0; 
} 
// This code is contributed by shivanisinghss2110






 

 
 










// Optimized implementation of Bubble sort 
#include <stdio.h> 
#include <stdbool.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]); 
    printf("n"); 
} 
  
// Driver program to test above functions 
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; 
} 






 

 
 










// 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); 
    } 
} 
  
  
// This code is contributed  
// by Nikita Tiwari. 






 

 
 










# Python3 Optimized implementation 
# of Bubble sort 
  
# An optimized version 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 no two elements were swapped 
        # by inner loop, then break 
        if swapped == False: 
            break
           
# Driver code to test above 
arr = [64, 34, 25, 12, 22, 11, 90] 
   
bubbleSort(arr) 
   
print ("Sorted array :") 
for i in range(len(arr)): 
    print ("%d" %arr[i],end=" ") 
  
# This code is contributed by Shreyanshi Arun 






 

 
 










// 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); 
    } 
  
} 
// This code is contributed by Sam007 






 

 
 










<?php  
// PHP Optimized implementation 
// of Bubble sort 
  
// An optimized version of Bubble Sort 
function bubbleSort(&$arr) 
{ 
    $n = sizeof($arr); 
  
    // Traverse through all array elements 
    for($i = 0; $i < $n; $i++) 
    { 
        $swapped = False; 
  
        // Last i elements are already 
        // in place 
        for ($j = 0; $j < $n - $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[$j+1]) 
            { 
                $t = $arr[$j]; 
                $arr[$j] = $arr[$j+1]; 
                $arr[$j+1] = $t; 
                $swapped = True; 
            } 
        } 
  
        // IF no two elements were swapped 
        // by inner loop, then break 
        if ($swapped == False) 
            break; 
    } 
} 
          
// Driver code to test above 
$arr = array(64, 34, 25, 12, 22, 11, 90);  
$len = sizeof($arr); 
bubbleSort($arr); 
  
echo "Sorted array : \n"; 
  
for($i = 0; $i < $len; $i++) 
    echo $arr[$i]." "; 
      
// This code is contributed by ChitraNayal. 
?> 






 

 
 










<script> 
  
// Optimized javaScript implementation 
// of Bubble sort 
// An optimized version of Bubble Sort 
function bubbleSort(arr, n) 
    { 
        var i, j, temp; 
        var 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  
    function printArray(arr, size) 
    { 
        var i; 
        for (i = 0; i < size; i++) 
            document.write(arr[i] + " "); 
        document.writeln(); 
    } 
  
    // Driver program 
        var arr = [ 64, 34, 25, 12, 22, 11, 90 ]; 
        var n = arr.length; 
        bubbleSort(arr, n); 
        document.write("Sorted array: "); 
        printArray(arr, n); 
  
// This code is contributed shivanisinghss2110 
</script> 






Sorted array: 
 1 2 3 4 5 7 8 9
Time Complexity: O(N2)Auxiliary Space: O(1)
The worst-case condition for bubble sort occurs when elements of the array are arranged in decreasing order.In the worst case, the total number of iterations or passes required to sort a given array is (n-1). where ‘n’ is a number of elements present in the array.
  At pass 1 :  Number of comparisons = (n-1)                     Number of swaps = (n-1)
  At pass 2 :  Number of comparisons = (n-2)                     Number of swaps = (n-2)
  At pass 3 :  Number of comparisons = (n-3)                    Number of swaps = (n-3)                              .                              .                              .  At pass n-1 :  Number of comparisons = 1                        Number of swaps = 1
Now , calculating total number of comparison required to sort the array= (n-1) + (n-2) +  (n-3) + . . . 2 + 1= (n-1)*(n-1+1)/2  { by using sum of N natural Number formula }= n (n-1)/2    
For the Worst case:
Total number of swaps = Total number of comparisonTotal number of comparison (Worst case) = n(n-1)/2Total number of swaps (Worst case) = n(n-1)/2
Worst and Average Case Time Complexity: O(N2). The worst case occurs when an array is reverse sorted.Best Case Time Complexity: O(N). The best case occurs when an array is already sorted.Auxiliary Space: O(1)
The idea is to place the largest element at their position and keep doing the same for every other elements.
Approach:
Place the largest element at their position, this operation makes sure that first largest element will be placed at the end of array.
Recursively call for rest n – 1 elements with same operation and placing the next greater element at their position.
Base condition for this recursion call would be, when number of elements in the array becomes 0 or 1 then, simply return (as they are already sorted).
Below is the implementation of the above approach:
C++
 

 
 










//C++ code for recursive bubble sort algorithm 
#include <iostream> 
using namespace std; 
void bubblesort(int arr[], int n) 
{ 
    if (n == 0 || n == 1) 
    { 
        return; 
    } 
    for (int i = 0; i < n - 1; i++) 
    { 
        if (arr[i] > arr[i + 1]) 
        { 
            swap(arr[i], arr[i + 1]); 
        } 
    } 
    bubblesort(arr, n - 1); 
} 
int main() 
{ 
    int arr[5] = {2, 5, 1, 6, 9}; 
    bubblesort(arr, 5); 
    for (int i = 0; i < 5; i++) 
    { 
        cout << arr[i] << " "; 
    } 
    return 0; 
} 
//code contributed by pragatikohli






1 2 5 6 9 
Bubble sort takes minimum time (Order of n) when elements are already sorted. Hence it is best to check if the array is already sorted or not beforehand, to avoid O(N2) time complexity.
Yes, Bubble sort performs swapping of adjacent pairs without the use of any major data structure. Hence Bubble sort algorithm is an in-place algorithm.
Yes, the bubble sort algorithm is stable.
Due to its simplicity, bubble sort is often used to introduce the concept of a sorting algorithm. In computer graphics, it is popular for its capability to detect a tiny error (like a swap of just two elements) in almost-sorted arrays and fix it with just linear complexity (2n). 
For example, it is used in a polygon filling algorithm, where bounding lines are sorted by their x coordinate at a specific scan line (a line parallel to the x-axis), and with incrementing y their order changes (two elements are swapped) only at intersections of two lines (Source: Wikipedia)  Bubble Sort | GeeksforGeeks - YouTubeGeeksforGeeks532K subscribersBubble Sort | GeeksforGeeksWatch laterShareCopy link6/21InfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 0:58•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=nmhjrI-aW5o" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Snapshots: Quiz on Bubble Sort
Other Sorting Algorithms on GeeksforGeeks/GeeksQuiz: Recursive Bubble SortCoding practice for sorting.
ukasp
SumitBM
rathbhupendra
TanishJain1
adityakangs
akshitsaxenaa09
shivanisinghss2110
amartyaghoshgfg
pathakanurag605
vaishalishrivastava21
kashishkumar2
animeshdey
pragatikohli12

redBus


Sorting

redBus
Sorting
Writing code in comment? 
                                    Please use ide.geeksforgeeks.org, 
                                    generate link and share the link here.