Bubble Sort Implementation in Java

By
Shivam Gupta
-
24
Bubble Sort Implementation in Java
Advertisement

Bubble Sort Implementation in Java

Bubble Sort, a classic sorting algorithm, serves as a foundational concept in the world of computer science. This guide explores the step-by-step implementation of Bubble Sort in Java, demystifying its mechanics and providing real-world examples to illustrate its effectiveness.

Understanding Bubble Sort:

Bubble Sort is a straightforward comparison-based algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The process continues until the entire list is sorted. While not the most efficient sorting algorithm, Bubble Sort’s simplicity makes it a valuable learning tool.

Java Implementation of Bubble Sort:

Below is a Java program demonstrating the implementation of Bubble Sort:

Java Program – Bubble Sort
public class BubbleSort {

    // Method to perform Bubble Sort on an array
    public static void bubbleSort(int[] array) {
        int n = array.length;

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                // Compare adjacent elements and swap if needed
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

    // Method to print the sorted array
    public static void printArray(int[] array) {
        int n = array.length;
        for (int i = 0; i < n; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

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

        System.out.println("Original Array:");
        printArray(array);

        // Apply Bubble Sort
        bubbleSort(array);

        System.out.println("Array after Bubble Sort:");
        printArray(array);
    }
}

Breaking Down the Implementation:

The bubbleSort Method:

  • Iterates through the array, comparing adjacent elements, and swaps them if needed, using a nested loop.
  • The outer loop controls the total number of passes, and the inner loop performs comparisons and swaps.

Real-world Example: Sorting Exam Scores:

  • Imagine you have a list of exam scores for a class. You could use Bubble Sort to arrange the scores in ascending order, making it easier to identify the highest and lowest scores.

Visualizing Bubble Sort:

  • Consider an array: [64, 34, 25, 12, 22, 11, 90].
  • The algorithm compares and swaps elements in multiple passes until the array is sorted: [11, 12, 22, 25, 34, 64, 90].

Understanding the Logic:

Let’s break down the logic behind Bubble Sort:

  • The algorithm compares adjacent elements in the array.
  • If the element on the left is greater than the one on the right, they are swapped.
  • This process is repeated for each pair of adjacent elements until the entire array is sorted.

Code Snippet to Visualize the Logic:

Consider a snippet of code to visualize the comparison and swapping of elements:

Java
// Assuming 'i' and 'j' are indices of elements to be compared
if (array[j] > array[j + 1]) {
    // Swap the elements
    int temp = array[j];
    array[j] = array[j + 1];
    array[j + 1] = temp;
}

This code snippet represents the essence of Bubble Sort, where elements are swapped if they are in the wrong order.

Output:

Output
Original Array:
64 34 25 12 22 11 90 
Array after Bubble Sort:
11 12 22 25 34 64 90

Time Complexity:

The time complexity of Bubble Sort is O(n^2) in the worst-case scenario. This is because, in the worst case, the algorithm needs to make approximately n/2 passes for each of the n elements in the array, resulting in a quadratic time complexity.

  • Best Case: O(n) – The best-case scenario occurs when the array is already sorted. However, Bubble Sort still needs to make a pass through the entire array to confirm that it is sorted, resulting in linear time complexity.
  • Average Case: O(n^2) – On average, Bubble Sort performs similarly to its worst-case scenario because it always makes n(n-1)/2 comparisons and swaps in the nested loops.

Space Complexity:

The space complexity of Bubble Sort is O(1) because the algorithm sorts the elements in-place. Bubble Sort only requires a constant amount of additional memory space to store temporary variables (e.g., temp in the swapping process) and loop counters.

In summary:

TypeComplexity
Time ComplexityO(n^2)
Space ComplexityO(1)

Conclusion:

Bubble Sort, though not the most efficient sorting algorithm, lays the foundation for understanding sorting techniques. Its simplicity makes it an excellent starting point for beginners in computer science. As you explore more complex algorithms, the principles learned from Bubble Sort become valuable building blocks in your programming journey. Happy coding!

Latest Posts:

RELATED ARTICLESMORE FROM AUTHOR