Bubble Sort Algorithm in DSA Java - Build from Scratch

Bubble Sort Algorithm

📖 Scenario: You have a list of numbers that are not in order. You want to arrange them from smallest to largest, like sorting books by height on a shelf.

🎯 Goal: Build a program that uses the bubble sort method to sort a list of numbers in ascending order.

📋 What You'll Learn

Create an integer array with exact values

Use a variable to store the length of the array

Implement the bubble sort algorithm using nested loops

Print the sorted array in the format: 1 -> 2 -> 3 -> null

💡 Why This Matters

🌍 Real World

Sorting helps organize data like arranging books, files, or contacts so you can find things quickly.

💼 Career

Understanding sorting algorithms is essential for software development, data analysis, and optimizing performance.

1

Create the array of numbers

Create an integer array called numbers with these exact values: 5, 3, 8, 4, 2

DSA Java

// Create the integer array called numbers with values 5, 3, 8, 4, 2
// Your code here

Hint

Use curly braces to list the numbers inside the array.

2

Store the length of the array

Create an integer variable called n and set it to the length of the numbers array using numbers.length

DSA Java

int[] numbers = {5, 3, 8, 4, 2};
// Create an integer variable n and set it to numbers.length
// Your code here

Hint

The length of an array in Java is accessed with arrayName.length.

3

Implement the bubble sort algorithm

Use two nested for loops with variables i and j to compare and swap adjacent elements in the numbers array to sort it in ascending order.

DSA Java

int[] numbers = {5, 3, 8, 4, 2};
int n = numbers.length;
// Use nested for loops with i and j to implement bubble sort
// Your code here

Hint

Compare each pair of neighbors and swap if the left one is bigger. Repeat until sorted.

4

Print the sorted array

Use a for loop with variable i to print the elements of the numbers array separated by -> and end with null.

DSA Java

int[] numbers = {5, 3, 8, 4, 2};
int n = numbers.length;
for (int i = 0; i  numbers[j + 1]) {
            int temp = numbers[j];
            numbers[j] = numbers[j + 1];
            numbers[j + 1] = temp;
        }
    }
}
// Print the sorted array elements separated by ' -> ' and end with 'null'
// Your code here

Hint

Print each number followed by ' -> ', then print 'null' at the end.

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