# Bubble Sort Algorithm

• Difficulty Level : Easy
• Last Updated : 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.

### How Bubble Sort Works?

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.

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

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

Illustration: Recommended Practice

Following are the implementations of Bubble Sort.

## C++

 `// C++ program for implementation  ` `// of Bubble sort ` `#include ` `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); ` `    ``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 < 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 */`

## Python3

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

 `// 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:
1 2 4 5 8 ```

### Optimized Implementation of Bubble Sort:

• 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++

 `// Optimized implementation of Bubble sort ` `#include ` `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); ` `    ``bubbleSort(arr, N); ` `    ``cout <<``"Sorted array: \n"``; ` `    ``printArray(arr, N); ` `    ``return` `0; ` `} ` `// This code is contributed by shivanisinghss2110`

## C

 `// Optimized implementation of Bubble sort ` `#include ` `#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. ` `?> `

## Javascript

 ` `

Output

```Sorted array:
1 2 3 4 5 7 8 9```

Time Complexity: O(N2)
Auxiliary Space: O(1)

### Worst Case Analysis for Bubble Sort:

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 comparison
Total number of comparison (Worst case) = n(n-1)/2
Total 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)

### Recursive Implementation Of Bubble Sort:

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 ` `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 = {2, 5, 1, 6, 9}; ` `    ``bubblesort(arr, 5); ` `    ``for` `(``int` `i = 0; i < 5; i++) ` `    ``{ ` `        ``cout << arr[i] << ``" "``; ` `    ``} ` `    ``return` `0; ` `} ` `//code contributed by pragatikohli`

Output

`1 2 5 6 9 `

### What is the Boundary Case for Bubble sort?

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.

### Does sorting happen in place in Bubble sort?

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.

### Is the Bubble sort algorithm stable?

Yes, the bubble sort algorithm is stable.

### Where is the Bubble sort algorithm used?

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)

Snapshots: Quiz on Bubble Sort

Other Sorting Algorithms on GeeksforGeeks/GeeksQuiz:
Recursive Bubble Sort
Coding practice for sorting.

My Personal Notes arrow_drop_up
Recommended Articles
Page :