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.

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

1. 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.

## 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);
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);
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);
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);
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.

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

Complexity: O(n2)

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

### Time Complexities:

• Worst Case Complexity:O(n2)

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(n2)

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.