Bubble Sort Algorithm in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Bubble Sort on a small array

What is the output of the following Java code after performing bubble sort on the array?

DSA Java

public class BubbleSortTest {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        bubbleSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }

    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++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

A 2 3 4 5 8

B 5 3 8 4 2

C 8 5 4 3 2

D 2 4 3 5 8

💡 Hint

Bubble sort repeatedly swaps adjacent elements if they are in wrong order.

The bubble sort algorithm compares adjacent elements and swaps them if the left element is greater than the right. After each pass, the largest unsorted element moves to its correct position at the end. After sorting, the array becomes sorted in ascending order: 2 3 4 5 8.

🧠 Conceptual

intermediate

Number of passes in Bubble Sort

For an array of length n, how many passes does the bubble sort algorithm perform in the worst case?

A n passes

B n/2 passes

C n-1 passes

D n+1 passes

💡 Hint

Each pass places one element in its correct position at the end.

Bubble sort performs n-1 passes in the worst case because after each pass, the largest unsorted element is placed at the end. After n-1 passes, all elements are sorted.

🔧 Debug

advanced

Identify the error in this bubble sort implementation

What error will occur when running this bubble sort code?

DSA Java

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]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

A NullPointerException

B ArrayIndexOutOfBoundsException

C Infinite loop

D No error, sorts correctly

💡 Hint

Check the inner loop boundary conditions carefully.

The inner loop runs with j from 0 to n - i, so when j = n - i - 1, accessing arr[j + 1] causes an index out of bounds error because arr[n] does not exist.

❓ Predict Output

advanced

Output after partial bubble sort passes

Given the array {7, 2, 9, 4} and running only one pass of bubble sort (one outer loop iteration), what is the array state?

DSA Java

int[] arr = {7, 2, 9, 4};
int n = arr.length;
for (int j = 0; j < n - 1; j++) {
    if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
    }
}
for (int num : arr) {
    System.out.print(num + " ");
}

A 2 4 7 9

B 7 2 4 9

C 7 9 2 4

D 2 7 4 9

💡 Hint

One pass moves the largest element to the end.

One pass compares adjacent pairs and swaps if needed. After one pass, the largest element 9 moves to the last position. The array becomes 2 7 4 9.

🧠 Conceptual

expert

Optimization to stop Bubble Sort early

Which modification can optimize bubble sort to stop early if the array is already sorted?

A Add a boolean flag to check if any swap happened in a pass; stop if none

B Reduce the array size by half after each pass

C Use recursion instead of loops

D Sort only the first half of the array

💡 Hint

If no swaps occur in a pass, the array is sorted.

Adding a boolean flag to track swaps during a pass allows the algorithm to stop early if no swaps happen, indicating the array is already sorted. This optimization improves best-case performance.

Practice

1. What is the main idea behind the Bubble Sort Algorithm?

easy

A. Insert each element into its correct position in a sorted sublist

B. Repeatedly swap adjacent elements if they are in the wrong order

C. Use a pivot to partition the list into smaller parts

D. Divide the list into halves and sort each half separately

Solution

1. Step 1: Understand Bubble Sort process

   Bubble sort compares adjacent elements and swaps them if they are out of order.

2. Step 2: Compare with other sorting methods

   Other options describe different algorithms: insertion sort (A), divide and conquer (B), quicksort (C).

3. Final Answer:

   Repeatedly swap adjacent elements if they are in the wrong order -> Option B

4. Quick Check:

   Bubble Sort = Swap adjacent pairs [OK]

Hint: Bubble sort swaps neighbors repeatedly until sorted [OK]

Common Mistakes:

• Confusing bubble sort with quicksort or merge sort
• Thinking bubble sort divides the list
• Assuming bubble sort inserts elements directly

2. Which of the following is the correct syntax to swap two elements arr[i] and arr[i+1] in Java during bubble sort?

easy

A. int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp;

B. arr[i] = arr[i+1]; arr[i+1] = arr[i];

C. swap(arr[i], arr[i+1]);

D. int temp = arr[i+1]; arr[i] = arr[i+1]; arr[i+1] = temp;

Solution

1. Step 1: Understand swapping in Java arrays

   To swap, use a temporary variable to hold one value, then assign values accordingly.

2. Step 2: Check each option

   int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; correctly uses a temp variable. arr[i] = arr[i+1]; arr[i+1] = arr[i]; overwrites arr[i] before saving it. swap(arr[i], arr[i+1]); is invalid syntax in Java. int temp = arr[i+1]; arr[i] = arr[i+1]; arr[i+1] = temp; overwrites arr[i] without saving original arr[i].

3. Final Answer:

   int temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; -> Option A

4. Quick Check:

   Use temp variable to swap [OK]

Hint: Always use a temp variable to swap two array elements [OK]

Common Mistakes:

• Overwriting one element before saving it
• Using a swap function that doesn't exist in Java
• Swapping without a temporary variable

3. What will be the output array after one full pass of bubble sort on int[] arr = {5, 3, 8, 4, 2}?

medium

A. [3, 5, 8, 4, 2]

B. [2, 3, 4, 5, 8]

C. [5, 3, 4, 2, 8]

D. [3, 5, 4, 2, 8]

Solution

1. Step 1: Perform one pass of bubble sort

   Compare and swap adjacent elements if needed:
   5 and 3: swap -> [3,5,8,4,2]
   5 and 8: no swap
   8 and 4: swap -> [3,5,4,8,2]
   8 and 2: swap -> [3,5,4,2,8]

2. Step 2: Result after first pass

   The largest element 8 moves to the end. The array is [3,5,4,2,8].

3. Final Answer:

   [3, 5, 4, 2, 8] -> Option D

4. Quick Check:

   One pass moves largest to end [OK]

Hint: One pass pushes largest element to the end [OK]

Common Mistakes:

• Not swapping all needed pairs in one pass
• Assuming full sort after one pass
• Confusing order of swaps

4. Identify the error in the following bubble sort code snippet:

for (int i = 0; i < arr.length; i++) {
  for (int j = 0; j < arr.length; j++) {
    if (arr[j] > arr[j+1]) {
      int temp = arr[j];
      arr[j] = arr[j+1];
      arr[j+1] = temp;
    }
  }
}

medium

A. Inner loop should run till arr.length - i - 1 to avoid index out of bounds

B. Outer loop should start from 1 instead of 0

C. Swap logic is incorrect, should swap arr[j+1] with arr[j-1]

D. No error, code is correct

Solution

1. Step 1: Analyze inner loop range

   Inner loop runs till arr.length, but accesses arr[j+1]. When j = arr.length - 1, arr[j+1] causes index out of bounds.

2. Step 2: Correct inner loop limit

   Inner loop should run till arr.length - i - 1 to avoid out of bounds and optimize sorting.

3. Final Answer:

   Inner loop should run till arr.length - i - 1 to avoid index out of bounds -> Option A

4. Quick Check:

   Prevent arr[j+1] out of bounds by limiting inner loop [OK]

Hint: Inner loop limit must prevent arr[j+1] overflow [OK]

Common Mistakes:

• Ignoring array index limits in inner loop
• Incorrect swap indices
• Assuming code runs without error

5. Given an array int[] arr = {4, 2, 7, 1, 3}, how many total swaps will bubble sort perform to fully sort the array?

hard

A. 7

B. 5

C. 6

D. 8

Solution

1. Step 1: Count swaps in each pass

   Pass 1:
   4>2 swap (1)
   4>7 no swap
   7>1 swap (2)
   7>3 swap (3)
   Array: [2,4,1,3,7]
   Pass 2:
   4>1 swap (4)
   4>3 swap (5)
   Array: [2,1,3,4,7]
   Pass 3:
   2>1 swap (6)
   Array: [1,2,3,4,7]
   Pass 4:
   No swaps

2. Step 2: Total swaps

   Total swaps = 6 swaps counted in passes 1-3.

3. Final Answer:

   6 -> Option C

4. Quick Check:

   Count swaps carefully per pass [OK]

Hint: Count swaps each pass until no swaps occur [OK]

Common Mistakes:

• Counting comparisons instead of swaps
• Missing swaps in later passes
• Assuming swaps equal to array length