Bubble Sort in Java

Bubble Sort Explained with Code

Bubble Sort is a basic comparison based sorting algorithm used to arrange elements in a data structure. In this method, each element is compared with its adjacent element, and they are swapped if they are not in the correct order.

  • Algorithm starts with comparing the first pair of elements.
  • If the first element is smaller than the second element, then the elements are swapped.
  • Algorithm is not suitable for large data sets.
bubble sort using Java

What is Bubble Sort?

Bubble Sort is a simple comparison based sorting algorithm. It works by repeatedly swapping adjacent elements if they are in the wrong order.

The largest element “bubbles up” to the end of the array in each iteration, hence the name Bubble Sort.

How Bubble Sort Works ?

Let’s understand Bubble Sort with a simple step by step explanation:

  1. Starting from the beginning of the array, compare the first and second elements.
  2. If the first element is greater than the second, swap them.
  3. Move to the next pair (second and third), and repeat the process till the end of the array.
  4. After the first pass, the largest element will be at the end.
  5. Repeat the same process for the remaining elements, excluding the last sorted elements.

This process is repeated n-1 times for an array of size n.

Bubble Sort Algorithm (Pseudocode)

function bubbleSort(array):
    n = length of array
    for i from 0 to n-1:
        swapped = false
        for j from 0 to n-i-2:
            if array[j] > array[j + 1]:
                swap(array[j], array[j + 1])
                swapped = true
        if not swapped:
            break

Swapped flag is used to check if the array is already sorted. If no swaps occur during a pass, the array is considered sorted, and the loop breaks early.

Bubble Sort in Java

Let’s take an example, we have a list of number stored in array….

Pass 1

  • ( 28 6 4 2 24 ) -> ( 6 28 4 2 24 ) : Swapped 28 & 6 since 28 > 6
  • ( 6 28 4 2 24 ) -> ( 6 4 28 2 24 ) : Swapped 28 & 4 since 28 > 4
  • ( 6 4 28 2 24 ) -> ( 6 4 2 28 24 ) : Swapped 28 & 2 since 28 > 2
  • ( 6 4 2 28 24 ) -> ( 6 4 2 24 28 ) : Swapped 28 & 24 since 28 > 24

This is called as bubble sort as you can see in each pass we get the largest element, which pushes (bubbles) towards the right always. Just like in a soda the largest bubble traverse to top of first.

Prime Course Trailer

Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Algorithm for Bubble Sort in Java

Steps to implement bubble sort in Java –

  • Step1: Repeat step 1 to 4 for i=0 to n
  • Step2: For j=0 to n
  • Step3: if(arr[j]>arr[j+1]
  • Step4: swap(arr[j],arr[j+1])
  • Step5: End

Java Program for Bubble Sort

Here is the Java implementation of the Bubble Sort algorithm:

Method 1: Basic Bubble Sort Method

This is a standard implementation of the Bubble Sort algorithm, which repeatedly compares adjacent elements and swaps them if they are in the wrong order.

How Bubble Sort works?

  • It uses two nested loops:
    • Outer loop runs n-1 times (for each pass).
    • Inner loop compares each adjacent pair and swaps if needed.
  • No optimization is done here, even if the array becomes sorted earlier.

Run
// Time Complexity: O(N^2)
// Space Complexity: O(1)

class Main {
    // Standard Bubble Sort function
    static void bubbleSort(int[] a) {
        int len = a.length;

        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - i - 1; j++) {
                // Compare adjacent elements
                if (a[j] > a[j + 1]) {
                    // Swap a[j] and a[j + 1]
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

    // Function to print the array
    static void printArray(int[] a) {
        for (int value : a) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};

        bubbleSort(arr);

        System.out.println("Sorted array:");
        printArray(arr);
    }
}

Output

Sorted array
11 12 22 25 34 64 90 

Bubble Sort in Java Optimized Implementation

This is an optimized version of the Bubble Sort algorithm, which includes a flag (swapped) to detect if the array is already sorted and avoid unnecessary passes.

Method 2: Optimized Bubble Sort Implementation

This is a standard implementation of the Bubble Sort algorithm, which repeatedly compares adjacent elements and swaps them if they are in the wrong order.

How Bubble Sort works with optimized approach?

  • Works the same way as Method 1, but:
    • Introduces a boolean swapped variable.
    • If no swaps occur in a full inner loop pass, the outer loop terminates early using break.
  • This avoids redundant iterations when the array is already sorted.
Run
// Time Complexity: O(N^2)
// Space Complexity: O(1)

class Main {
    // Optimized Bubble Sort with early termination
    static void bubbleSort(int[] a) {
        int len = a.length;

        for (int i = 0; i < len - 1; i++) {
            boolean swapped = false;

            for (int j = 0; j < len - i - 1; j++) { if (a[j] > a[j + 1]) {
                    // Swap a[j] and a[j + 1]
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    swapped = true;
                }
            }

            // If no two elements were swapped, array is sorted
            if (!swapped) {
                break;
            }
        }
    }

    // Function to print the array
    static void printArray(int[] a) {
        for (int value : a) {
            System.out.print(value + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};

        bubbleSort(arr);

        System.out.println("Sorted array:");
        printArray(arr);
    }
}

Bubble Sort Algorithm Explained

Bubble Sort in java
Bubble Sort in java

Why Bubble Sort is Not Used in Practice?

Although Bubble Sort is conceptually simple, it is not efficient for large datasets. Most real world sorting problems use more efficient algorithms like Merge Sort, Quick Sort, or built-in sorting functions.

However, Bubble Sort is often used:

  • For educational purposes
  • When the input size is very small
  • In environments where code simplicity is more important than efficiency

Conclusion

Bubble Sort is an easy to understand, basic sorting algorithm that provides an excellent introduction to the concept of sorting.

  • Despite its inefficiencies, understanding Bubble Sort in Java helps lay the groundwork for learning more complex algorithms.
  • It is stable, simple, and demonstrates the core principles of sorting algorithms like comparisons, swapping, and early termination optimization.
  • While it’s not ideal for real world use on large datasets, its role in foundational learning and small applications remains important
Bubble Sort in Java meme

FAQ's related to Bubble Sort in Java

Answer:

Yes. Bubble Sort is a stable sorting algorithm as it does not change the relative order of equal elements.

Answer:

Yes. You can adapt Bubble Sort to sort strings lexicographically by comparing characters using compareTo().

Answer:

Its O(n²) time complexity in the average and worst cases makes it highly inefficient for large datasets.

Answer:

Only in cases with very small input sizes or nearly sorted data, where its simplicity outweighs its inefficiency.

 

Answer:

  1. If your data is sorted and random access is allowed (like arrays), Binary Search is objectively the fastest general purpose search algorithm in terms of time complexity.
  2. If the data is unsorted, then Hashing (e.g., using a Hash Table) gives average case (1) time, but that’s for key-value lookups—not ordered search.

Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others

Checkout list of all the video courses in PrepInsta Prime Subscription

Checkout list of all the video courses in PrepInsta Prime Subscription

4 comments on “Bubble Sort in Java”