Skip to content
Related Articles
Bubble Sort
• Difficulty Level : Easy
• Last Updated : 07 May, 2021

Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order.
Example:
First Pass:
( 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:
( 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
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.
Third Pass:
( 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

Following is the implementations of Bubble Sort.

## C++

 `// C++ program for implementation of Bubble sort``#include ``using` `namespace` `std;` `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++)``        ``cout << arr[i] << ``" "``;``    ``cout << endl;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = {64, 34, 25, 12, 22, 11, 90};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``bubbleSort(arr, n);``    ``cout<<``"Sorted array: \n"``;``    ``printArray(arr, n);``    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `// C program for implementation of Bubble sort``#include ` `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);``    ``bubbleSort(arr, n);``    ``printf``(``"Sorted array: \n"``);``    ``printArray(arr, n);``    ``return` `0;``}`

## Java

 `// 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

## Python

 `# 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]),`

## C#

 `// 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

 ` ``\$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.``?>`

## Javascript

 ``

Output:

```Sorted array:
11 12 22 25 34 64 90```

<!—-Illustration : —>
Optimized Implementation:
The above function always runs O(n^2) time even if the array is sorted. It can be optimized by stopping the algorithm if inner loop didn’t cause any swap.

## CPP

 `// Optimized implementation of Bubble sort``#include ` `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);``    ``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);``    ``}``}`  `// This code is contributed``// by Nikita Tiwari.`

## Python3

 `# 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`

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

## PHP

 ` ``\$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.``?>`

Output:

```Sorted array:
11 12 22 25 34 64 90```

Worst and Average Case Time Complexity: O(n*n). Worst case occurs when array is reverse sorted.
Best Case Time Complexity: O(n). Best case occurs when array is already sorted.
Auxiliary Space: O(1)
Boundary Cases: Bubble sort takes minimum time (Order of n) when elements are already sorted.
Sorting In Place: Yes
Stable: Yes
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 very small error (like 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 x axis) and with incrementing y their order changes (two elements are swapped) only at intersections of two lines (Source: Wikipedia)

https://youtu.be/nmhjrI

-aW5o

Snapshots:

Quiz on Bubble Sort
Other Sorting Algorithms on GeeksforGeeks/GeeksQuiz:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up