View all stories

Bubble Sort in Java: A Simple Guide 2025

By /
Spread the love

Bubble Sort in Java: A Simple Guide for Students

Sorting is a fundamental concept in programming, and one of the simplest sorting algorithms is Bubble Sort. It’s often the first sorting algorithm students learn because of its simplicity and ease of understanding.

In this guide, we will explain Bubble Sort in Java with step-by-step explanations, examples, and code snippets.

What is Bubble Sort?

Bubble Sort is a simple sorting algorithm that repeatedly compares and swaps adjacent elements if they are in the wrong order. This process continues until the entire list is sorted.

Think of it like bubbles rising in water—the largest elements “bubble up” to the top with each pass through the array.

Bubble sort in java

How Does Bubble Sort Work?

  1. Start from the first element.
  2. Compare the current element with the next one.
  3. If they are in the wrong order, swap them.
  4. Move to the next pair and repeat.
  5. After one full pass, the largest element moves to the end.
  6. Repeat the process for the remaining elements until the list is sorted.

Read More about: JPG /JPEG

Example:

Consider the following unsorted array:

[5, 3, 8, 4, 2]

Pass 1:

  • Compare 5 and 3 → Swap → [3, 5, 8, 4, 2]
  • Compare 5 and 8 → No Swap
  • Compare 8 and 4 → Swap → [3, 5, 4, 8, 2]
  • Compare 8 and 2 → Swap → [3, 5, 4, 2, 8]

Pass 2:

  • Compare 3 and 5 → No Swap
  • Compare 5 and 4 → Swap → [3, 4, 5, 2, 8]
  • Compare 5 and 2 → Swap → [3, 4, 2, 5, 8]

Pass 3:

  • Compare 3 and 4 → No Swap
  • Compare 4 and 2 → Swap → [3, 2, 4, 5, 8]

Pass 4:

  • Compare 3 and 2 → Swap → [2, 3, 4, 5, 8]

Now the list is sorted!

Bubble Sort Algorithm in Java

Here is a Java program to implement Bubble Sort:

public class BubbleSort {
    public 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 elements
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    
    public static void printArray(int arr[]) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }

    public static void main(String args[]) {
        int arr[] = {5, 3, 8, 4, 2};
        System.out.println("Unsorted array:");
        printArray(arr);

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

Optimized Bubble Sort in Java

An optimized version stops early if no swaps are made in a pass, meaning the array is already sorted.

public class OptimizedBubbleSort {
    public static void bubbleSort(int arr[]) {
        int n = arr.length;
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            // If no two elements were swapped, break
            if (!swapped) break;
        }
    }
}

Download Java From Here Download

Time Complexity of Bubble Sort

Case Time Complexity
Best Case (Already Sorted) O(n)
Worst Case (Reversed Order) O(n²)
Average Case O(n²)

Advantages of Bubble Sort

  •  Simple to understand and implement.
  •  Works well for small datasets.
  •  Requires no extra memory (in-place sorting).

Disadvantages of Bubble Sort

  •  Very slow for large datasets.
  •  Inefficient compared to other sorting algorithms.
  •  Requires multiple passes even if partially sorted.

When to Use Bubble Sort?

  • When teaching sorting concepts to beginners.
  • When working with small datasets.
  • When a simple implementation is preferred over performance.

Better Alternatives to Bubble Sort

Algorithm Complexity Best Use Case
Quick Sort O(n log n) Fastest for large datasets
Merge Sort O(n log n) Works well for linked lists
Insertion Sort O(n²) Efficient for small or nearly sorted arrays

Conclusion

Bubble Sort is a basic but inefficient sorting algorithm. While it’s great for learning purposes, it is not used in real-world applications where performance matters. Students should understand Bubble Sort as a stepping stone to more efficient sorting techniques like Quick Sort or Merge Sort.

By understanding Bubble Sort, you’ll gain a solid foundation in sorting algorithms, preparing you to explore more advanced concepts in computer science.

FAQs

1. Why is Bubble Sort called Bubble Sort?

It’s called Bubble Sort because larger elements “bubble up” to the top during sorting.

2. Is Bubble Sort stable?

Yes, Bubble Sort is a stable sorting algorithm as it preserves the order of equal elements.

3. Why is Bubble Sort inefficient?

Bubble Sort has a worst-case time complexity of O(n²), making it slow for large datasets.

4. When should I use Bubble Sort?

Only for educational purposes or when working with very small datasets.

5. What is the best case time complexity of Bubble Sort?

If the array is already sorted, the best case time complexity is O(n).

Related Posts