# Bubble Sort in Java

(Last Updated On: 18/10/2023)

Sorting is a fundamental operation in computer science and plays a crucial role in various applications, from data processing to algorithm design. Among the numerous sorting algorithms available, Bubble Sort is one of the simplest to understand and implement.

In this blog, we’ll understand the concept of Bubble Sort, a straightforward sorting technique, and explore how it works in Java. Whether you’re new to sorting algorithms or looking to refresh your knowledge, understanding Bubble Sort is a valuable addition to your programming skills.

## What is Bubble Sort in Java?

Bubble Sort is a simple sorting algorithm used in Java to arrange elements in ascending or descending order. It repeatedly compares adjacent elements in an array and swaps them if they are in the wrong order. This process continues until the entire array is sorted.

### Sorting an Integer Array Using Bubble Sort in Java

The provided code displays the Bubble Sort algorithm in Java for sorting an array of integers.

```// Bubble Sort in Java
import java.io.*;
public class BubbleSortEx {
static void bubbleSrt(int arr[], int n){
int i, j, temp;
boolean swap;
for (i = 0; i < n - 1; i++) {
swap = 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;
swap = true;
}
}
if (swap == false)
break;
}
}
static void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
public static void main(String args[]){
int arr[] = { 6, 4, 2, 1, 3, 9, 7 };
int n = arr.length;
bubbleSrt(arr, n);
System.out.println("Sorted array: ");
printArray(arr, n);
}
}```

Unlock a World of Binary Search in Java Today!

Explanation of the code:

1. `bubbleSrt` method: This method takes an array `arr` and its length `n` as parameters and sorts the array using the Bubble Sort algorithm.

– `i`, `j`, and `temp` are used for looping and temporary storage.

– `swap` is a flag that helps determine if any swaps were made in a pass.

2. Outer Loop (`for i`): This loop runs from 0 to `n – 1` times, where `i` represents the pass number.

3. Inner Loop (`for j`): This loop runs from 0 to `n – i – 1` times. It compares adjacent elements and swaps them if they are in the wrong order.

– If `arr[j]` is greater than `arr[j + 1]`, it swaps these two elements.

– `swap` is set to `true` if any swaps occur in the past.

4. After each pass, the code checks if no swaps occurred (`if (swap == false)`). If no swaps happened, the array is already sorted, and the loop breaks early.

5. The `printArray` method is used to print the sorted array.

6. In the `main` method:

– An integer array `arr` is initialized with unsorted values.

– The `bubbleSrt` method is called to sort the array.

– The sorted array is printed using the `printArray` method.

Bubble Sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. This process is repeated for each pass until no more swaps are needed, which indicates that the array is sorted.

#### Output:

``````Sorted array:
1 2 3 4 6 7 9 ``````

Learn about For loops in Python and level up your programming skills today!

1. Simplicity: Bubble Sort is one of the simplest sorting algorithms to understand and implement. It’s an excellent choice for educational purposes and small datasets.

2. Ease of Implementation: Implementing Bubble Sort in Java or other programming languages is straightforward, making it a good choice for quick sorting needs.

3. No Additional Space: Bubble Sort operates on the input array itself, meaning it doesn’t require additional memory for temporary storage.

1. Inefficiency for Large Datasets: Bubble Sort’s time complexity of O(n^2) makes it highly inefficient for sorting large datasets. Its performance degrades significantly as the dataset size increases.

2. Unsuitable for Real-World Applications: Due to its inefficiency, Bubble Sort is not a practical choice for real-world applications where sorting speed is crucial.

3. Lack of Adaptability: Bubble Sort doesn’t adapt well to pre-sorted or partially sorted arrays, making it less versatile than other sorting algorithms.

## Real-World Applications of Bubble Sort in Java

Dive into Linear Search in Java Now!

Bubble Sort, despite its inefficiency for large datasets, finds applications in specific scenarios where sorting speed is not a primary concern. In this section, we will explore practical scenarios where Bubble Sort is used, discuss its limitations in real-world applications, and highlight alternatives for specific use cases.

### Practical Scenarios:

1. Educational and Learning Purposes: Bubble Sort serves as an excellent teaching tool for beginners learning sorting algorithms and programming. Its simplicity and ease of implementation make it a valuable introductory algorithm.

2. Small Datasets: In situations where the dataset is relatively small, such as sorting a short list of items or organizing a small set of data, Bubble Sort can be sufficient. Its simplicity makes it suitable for ad-hoc sorting needs.

3. Benchmarking and Testing: Bubble Sort is occasionally used in benchmarking and testing scenarios to compare the performance of other sorting algorithms. Its predictable behavior and easy implementation make it a useful reference point.

### Limitations in Real-World Applications:

1. Inefficiency for Large Datasets: Bubble Sort’s time complexity of O(n^2) makes it impractical for sorting large datasets. As dataset size increases, its performance deteriorates significantly, making it unsuitable for applications with extensive data processing needs.

2. Lack of Adaptability: Bubble Sort doesn’t adapt well to already sorted or partially sorted datasets, leading to unnecessary iterations. In real-world applications, adaptability is crucial for optimizing sorting operations.

### Alternatives in Specific Use Cases:

1. Insertion Sort: For small datasets or nearly sorted lists, Insertion Sort can be a more efficient alternative to Bubble Sort due to its adaptability to pre-sorted elements.

2. QuickSort or MergeSort: When sorting speed is essential for larger datasets, more advanced algorithms like QuickSort or MergeSort are better choices. They offer superior time complexity for practical applications.

3. Java’s Built-in Sorting Algorithms: Java provides efficient sorting methods like Arrays.sort() or Collections.sort() that are suitable for various real-world applications. These methods employ optimized sorting algorithms under the hood.

In conclusion, Bubble Sort in Java, while a straightforward sorting algorithm, may not be the go-to choice for large datasets due to its inefficiency. It serves as a valuable learning tool and can be suitable for smaller datasets. Understanding its advantages and limitations, along with exploring alternative sorting methods, empowers developers to make informed choices for real-world applications.

You can improve your programming abilities by learning how to use Bubble Sort in Java, making connections with other sorting methods, and implementing effective tactics. Explore our blog and course offerings at Newtum to find out more about Bubble Sort and other programming-related topics. Enhance the coding experience with Newtum!