In this tutorial, you will learn how **bubble sort** works. Additionally, you will discover working instances of bubble sort in C, C++, Java, and Python.

Contents

## What is a Bubble Sort?

**Bubble Sort** is a sorting algorithm used to sort list items in ascending order by comparing two adjacent values. On the off chance that the first value is higher than the second value, the first value requires the second value position, while the second value takes the primary value position. In the event that the primary value is lower than the second value, no swapping is finished.

This process is repeated until all the values in the list have been compared and swapped if vital. Every iteration is typically called a pass. The quantity of passes in a bubble sort is equivalent to the number of elements in a list minus one.

bubble sort is an algorithm that compares the adjacent elements and swaps their positions on the off chance that they are not in the intended order. The order can be ascending or descending.

## How Bubble Sort Works?

- Beginning from the primary list, think about the first and the second elements. If the first element is greater than the second element, they are swapped.

Presently, look at the second and the third elements. Swap them in the event that they are not all together.

The above interaction goes on until the last element.

2. A similar interaction continues for the remaining iterations. After every iteration, the largest element among the unsorted elements is set toward the end.

In every iteration, the comparison happens up to the last unsorted element.

The array is arranged when all the unsorted elements are put at their right positions.

Compare the adjacent elements

Compare the adjacent elements

Compare the adjacent elements

## Bubble Sort Algorithm

bubbleSort(array) for i <- 1 to indexOfLastUnsortedElement-1 if leftElement > rightElement swap leftElement and rightElement end bubbleSort

## Python, Java, and C/C++ Examples

**Python**

# Optimized bubble sort in python def bubbleSort(array): # Run loops two times: one for walking throught the array # and the other for comparison for i in range(len(array)): # swapped keeps track of swapping swapped = True for j in range(0, len(array) - i - 1): # To sort in descending order, change > to < in this line. if array[j] > array[j + 1]: # Swap if greater is at the rear position (array[j], array[j + 1]) = (array[j + 1], array[j]) swapped = False # If there is not swapping in the last swap, then the array is already sorted. if swapped: break data = [-2, 45, 0, 11, -9] bubbleSort(data) print('Sorted Array in Ascending Order:') print(data)

**Java**

// Optimized bubble sort in Java import java.util.Arrays; class BubbleSort { void bubbleSort(int array[]) { int size = array.length; // Run loops two times: one for walking throught the array // and the other for comparison for (int i = 0; i < size - 1; i++) { // swapped keeps track of swapping boolean swapped = true; for (int j = 0; j < size - i - 1; j++) { // To sort in descending order, change > to < in this line. if (array[j] > array[j + 1]) { // Swap if greater is at the rear position int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; swapped = false; } } // If there is not swapping in the last swap, then the array is already sorted. if (swapped == true) break; } } // Driver code public static void main(String args[]) { int[] data = { -2, 45, 0, 11, -9 }; BubbleSort bs = new BubbleSort(); bs.bubbleSort(data); System.out.println("Sorted Array in Ascending Order:"); System.out.println(Arrays.toString(data)); } }

**C**

// Optimized bubble sort in C #include <stdio.h> void bubbleSort(int arrayay[], int size) { for (int step = 0; step < size - 1; ++step) { // Swapped keeps track of swapping int swapped = 0; // Run loops two times: one for walking throught the array // and the other for comparison for (int i = 0; i < size - step - 1; ++i) { // To sort in descending order, change > to < in this line. if (arrayay[i] > arrayay[i + 1]) { // Swap if greater is at the rear position int temp = arrayay[i]; arrayay[i] = arrayay[i + 1]; arrayay[i + 1] = temp; swapped = 1; } } // If there is not swapping in the last swap, then the array is already sorted. if (swapped == 0) break; } } // Function to print an array void printarrayay(int arrayay[], int size) { for (int i = 0; i < size; ++i) { printf("%d ", arrayay[i]); } printf("\n"); } // Driver code int main() { int data[] = {-2, 45, 0, 11, -9}; int size = sizeof(data) / sizeof(data[0]); bubbleSort(data, size); printf("Sorted Array in Ascending Order:\n"); printarrayay(data, size); }

**c++**

// Optimized bubble sort in C++ #include <iostream> using namespace std; void bubbleSort(int array[], int size) { for (int step = 0; step < size - 1; ++step) { // Run loops two times: one for walking throught the array // and the other for comparison int swapped = 0; for (int i = 0; i < size - step - 1; ++i) { // To sort in descending order, change > to < in this line. if (array[i] > array[i + 1]) { // Swap if greater is at the rear position int temp = array[i]; array[i] = array[i + 1]; array[i + 1] = temp; swapped = 1; } } // If there is not swapping in the last swap, then the array is already sorted. if (swapped == 0) break; } } // Function to print an array void printArray(int array[], int size) { for (int i = 0; i < size; ++i) { cout << " " << array[i]; } cout << "\n"; } // Driver code int main() { int data[] = {-2, 45, 0, 11, -9}; int size = sizeof(data) / sizeof(data[0]); bubbleSort(data, size); cout << "Sorted Array in Ascending Order:\n"; printArray(data, size); }

## Optimized Bubble Sort

In the above code, all potential comparisons are made even if the array is as of now sorted. It builds the execution time.

The code can be optimized by presenting an additional variable swapped. After every iteration, on the off chance that there is no swapping occurring, there is no requirement for performing further loops.

In such a case, the variable swapped is set false. Consequently, we can prevent further iterations.

Algorithm for optimized bubble sort is

bubbleSort(array) swapped <- false for i <- 1 to indexOfLastUnsortedElement-1 if leftElement > rightElement swap leftElement and rightElement swapped <- true end bubbleSort

## Optimized Bubble Sort Examples

**Python**

# Optimized bubble sort in python def bubbleSort(array): # Run loops two times: one for walking throught the array # and the other for comparison for i in range(len(array)): # swapped keeps track of swapping swapped = True for j in range(0, len(array) - i - 1): # To sort in descending order, change > to < in this line. if array[j] > array[j + 1]: # Swap if greater is at the rear position (array[j], array[j + 1]) = (array[j + 1], array[j]) swapped = False # If there is not swapping in the last swap, then the array is already sorted. if swapped: break data = [-2, 45, 0, 11, -9] bubbleSort(data) print('Sorted Array in Ascending Order:') print(data)

**Java**

// Optimized bubble sort in Java import java.util.Arrays; class BubbleSort { void bubbleSort(int array[]) { int size = array.length; // Run loops two times: one for walking throught the array // and the other for comparison for (int i = 0; i < size - 1; i++) { // swapped keeps track of swapping boolean swapped = true; for (int j = 0; j < size - i - 1; j++) { // To sort in descending order, change > to < in this line. if (array[j] > array[j + 1]) { // Swap if greater is at the rear position int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; swapped = false; } } // If there is not swapping in the last swap, then the array is already sorted. if (swapped == true) break; } } // Driver code public static void main(String args[]) { int[] data = { -2, 45, 0, 11, -9 }; BubbleSort bs = new BubbleSort(); bs.bubbleSort(data); System.out.println("Sorted Array in Ascending Order:"); System.out.println(Arrays.toString(data)); } }

**C**

// Optimized bubble sort in C #include <stdio.h> void bubbleSort(int arrayay[], int size) { for (int step = 0; step < size - 1; ++step) { // Swapped keeps track of swapping int swapped = 0; // Run loops two times: one for walking throught the array // and the other for comparison for (int i = 0; i < size - step - 1; ++i) { // To sort in descending order, change > to < in this line. if (arrayay[i] > arrayay[i + 1]) { // Swap if greater is at the rear position int temp = arrayay[i]; arrayay[i] = arrayay[i + 1]; arrayay[i + 1] = temp; swapped = 1; } } // If there is not swapping in the last swap, then the array is already sorted. if (swapped == 0) break; } } // Function to print an array void printarrayay(int arrayay[], int size) { for (int i = 0; i < size; ++i) { printf("%d ", arrayay[i]); } printf("\n"); } // Driver code int main() { int data[] = {-2, 45, 0, 11, -9}; int size = sizeof(data) / sizeof(data[0]); bubbleSort(data, size); printf("Sorted Array in Ascending Order:\n"); printarrayay(data, size); }

**C++**

// Optimized bubble sort in C++ #include <iostream> using namespace std; void bubbleSort(int array[], int size) { for (int step = 0; step < size - 1; ++step) { // Run loops two times: one for walking throught the array // and the other for comparison int swapped = 0; for (int i = 0; i < size - step - 1; ++i) { // To sort in descending order, change > to < in this line. if (array[i] > array[i + 1]) { // Swap if greater is at the rear position int temp = array[i]; array[i] = array[i + 1]; array[i + 1] = temp; swapped = 1; } } // If there is not swapping in the last swap, then the array is already sorted. if (swapped == 0) break; } } // Function to print an array void printArray(int array[], int size) { for (int i = 0; i < size; ++i) { cout << " " << array[i]; } cout << "\n"; } // Driver code int main() { int data[] = {-2, 45, 0, 11, -9}; int size = sizeof(data) / sizeof(data[0]); bubbleSort(data, size); cout << "Sorted Array in Ascending Order:\n"; printArray(data, size); }

## Complexity

Bubble Sort is one of the easiest sorting algorithms. Two loops are actualized in the algorithm.

Cycle | Number of Comparisons |

1st | (n-1) |

2nd | (n-2) |

3rd | (n-3) |

……. | …… |

last | 1 |

Number of examinations: (n – 1) + (n – 2) + (n – 3) +…..+ 1 = n(n – 1)/2 almost equivalents to n^{2}

**Complexity: **O(n^{2})

Additionally, we can analyze the complexity by basically noticing the number of loops. There are 2 loops so the complexity is n*n = n^{2}

### Time Complexities:

**Worst Case Complexity:**O(n^{2})

On the off chance that we need to sort in ascending order and the array is in descending order at that point, the worst scenario happens.

**Best Case Complexity:**O(n)

On the off chance that the array is now arranged, there is no requirement for sorting.

**Average Case Complexity:**O(n^{2})

It happens when the elements of the array are in jumbled order (neither ascending nor descending).

**Space Complexity:**

Space complexity is O(1) in light of the fact that an additional variable temp is used for swapping.

In the optimized algorithm, the variable swapped adds to the space complexity accordingly, making it O(2).

## Bubble Sort Applications

Bubble sort is used in the following cases where

- the complexity of the code does not matter.
- a shortcode is preferred.

Thanks for reading! We hope you found this tutorial helpful and we would love to hear your feedback in the Comments section below. And show us what you’ve learned by sharing your photos and creative projects with us.