Bubble Sort in Java

Q: How does bubble sort work?

Bubble sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. After each pass, the largest remaining element "bubbles up" to its final position at the end of the array.

Q: Write an optimized bubble sort in Java that stops early.

Java example: import java.util.Arrays; public class BubbleSort { static void bubbleSort(int[] arr) { for (int pass = 0; pass arr[i + 1]) { int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; swapped = true; } } if (!swapped) { break; // no swaps: the array is already sorted } } } public static void main(String[] args) { int[] arr = {5, 1, 4, 2, 8}; bubbleSort(arr); System.out.println(Arrays.toString(arr)); // [1, 2, 4, 5, 8] } }

Q: What is the time complexity of bubble sort?

Worst and average case: O(n 2 ). Best case: O(n) with the early-exit flag, when the array is already sorted. Space: O(1), it sorts in place.

Q: Is bubble sort stable?

Yes. It swaps only when arr[i] > arr[i + 1], never for equal elements, so equal values keep their original relative order.

Q: Write bubble sort for an array of strings in Java.

compareTo returns a positive number when the first string comes later in alphabetical order.

Q: How many swaps does bubble sort make?

Exactly as many as the number of inversions, the pairs that are out of order. A reversed array of n elements has n(n - 1) / 2 inversions, the maximum.

Q: Write a Java method that counts the passes bubble sort needs.

Java example: static int countPasses(int[] arr) { int passes = 0; boolean swapped = true; for (int pass = 0; pass arr[i + 1]) { int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; swapped = true; } } } return passes; }

Q: What is the difference between bubble sort and selection sort?

Both are O(n 2 ). Bubble sort swaps adjacent elements many times per pass and is stable; selection sort finds the minimum and makes at most one swap per pass, but it is not stable. Bubble sort can stop early on sorted input; selection sort cannot.

Bubble Sort in Java

Sorting is the process of arranging a list of unsorted data in a particular order, either ascending or descending. Sort algorithms play a very crucial role for organizing unsorted data and facilitating efficient searching, retrieval, and analysis.

Every sorting algorithm has a unique approach for sorting the data; these sorting algorithms are used according to the specific requirements of the problem, including data size, structure, and distribution, as well as time and space constraints.

In this tutorial, we are going to learn all about Bubble Sort in Java.

Java program for implementation of Bubble Sort

BubbleSortExample.java

class BubbleSortExample {
  // A Function to sort an array using Bubble Sort technique
  static void bubbleSort(int array[]) {
    int i, j, temp;
    boolean swapped;
    for (i = 0; i < array.length - 1; i++) {
      swapped = false;
      for (j = 0; j < array.length - i - 1; j++) {
        if (array[j] > array[j + 1]) {

          // Swap array[j] and array[j+1]
          temp = array[j];
          array[j] = array[j + 1];
          array[j + 1] = temp;
          swapped = true;
        }
      }

      // Loop breaks, if no two elements were swapped by inner loop
      if (swapped == false)
        break;
    }
  }

  // Function to print an array
  static void printArray(int array[]) {
    for (int i = 0; i < array.length; i++)
      System.out.print(array[i] + " ");
    System.out.println();
  }

  public static void main(String args[]) {
    // Creates an array
    int array[] = { 40, 70, 90, 20, 80, 100, 60, 10, 30, 50 };
    System.out.println("Created array elements: ");
    // Printing created array elements
    printArray(array);
    // Calling a method to sort an array
    bubbleSort(array);
    System.out.println("\nSorted array elements: ");
    // Printing sorted array elements
    printArray(array);
  }
}

Output

Created array elements:
40, 70, 90, 20, 80, 100, 60, 10, 30, 50

Sorted array elements:
10 20 30 40 50 60 70 80 90 100

Frequently Asked Questions (FAQ)

Q1. How does bubble sort work?

Bubble sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. After each pass, the largest remaining element "bubbles up" to its final position at the end of the array.

Q2. Write an optimized bubble sort in Java that stops early.

BubbleSort.java

import java.util.Arrays;

public class BubbleSort {

    static void bubbleSort(int[] arr) {
        for (int pass = 0; pass < arr.length - 1; pass++) {
            boolean swapped = false;
            for (int i = 0; i < arr.length - 1 - pass; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) {
                break;              // no swaps: the array is already sorted
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 1, 4, 2, 8};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));   // [1, 2, 4, 5, 8]
    }
}

Q3. What is the time complexity of bubble sort?

Worst and average case: O(n²).
Best case: O(n) with the early-exit flag, when the array is already sorted.
Space: O(1), it sorts in place.

Q4. Why does the inner loop run to arr.length - 1 - pass?

After each pass, the largest remaining element is already in its final place at the end. The last pass elements are sorted, so comparing them again is wasted work.

Q5. Is bubble sort stable?

Yes. It swaps only when arr[i] > arr[i + 1], never for equal elements, so equal values keep their original relative order.

Q6. Write bubble sort for an array of strings in Java.

BubbleSortStrings.java

static void sort(String[] words) {
    for (int pass = 0; pass < words.length - 1; pass++) {
        for (int i = 0; i < words.length - 1 - pass; i++) {
            if (words[i].compareTo(words[i + 1]) > 0) {
                String temp = words[i];
                words[i] = words[i + 1];
                words[i + 1] = temp;
            }
        }
    }
}

compareTo returns a positive number when the first string comes later in alphabetical order.

Q7. How many swaps does bubble sort make?

Exactly as many as the number of inversions, the pairs that are out of order. A reversed array of n elements has n(n - 1) / 2 inversions, the maximum.

Q8. Write a Java method that counts the passes bubble sort needs.

CountPasses.java

static int countPasses(int[] arr) {
    int passes = 0;
    boolean swapped = true;
    for (int pass = 0; pass < arr.length - 1 && swapped; pass++) {
        swapped = false;
        passes++;
        for (int i = 0; i < arr.length - 1 - pass; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp;
                swapped = true;
            }
        }
    }
    return passes;
}

Q9. When is bubble sort useful in practice?

Rarely. It is mainly used for teaching. It can be acceptable for tiny arrays or for checking whether an array is already sorted in one O(n) pass, but insertion sort is usually better even for small inputs.

Q10. What is the difference between bubble sort and selection sort?

Both are O(n²). Bubble sort swaps adjacent elements many times per pass and is stable; selection sort finds the minimum and makes at most one swap per pass, but it is not stable. Bubble sort can stop early on sorted input; selection sort cannot.

Was this tutorial helpful?

Help Us Improve

Java program for implementation of Bubble Sort

Frequently Asked Questions (FAQ)