Bubble Sort Algorithm in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to swap two elements in the array.

DSA C++

int temp = arr[i];
arr[i] = arr[[1]];
arr[[1]] = temp;

Drag options to blanks, or click blank then click option'

Aj

Bi+1

Ci-1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong index for swapping, like j or i-1.

Swapping with a fixed index like 0 instead of the next element.

In bubble sort, we swap the current element arr[i] with the next element arr[i+1] if they are out of order.

2fill in blank

medium

Complete the code to run the inner loop of bubble sort correctly.

DSA C++

for (int j = 0; j < n - [1] - 1; j++) {
    if (arr[j] > arr[j + 1]) {
        // swap
    }
}

Drag options to blanks, or click blank then click option'

Ai

Bj

Cn

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using j instead of i in the inner loop limit.

Not reducing the inner loop range, causing unnecessary comparisons.

The inner loop runs fewer times each pass because the largest elements bubble to the end. So it runs up to n - i - 1.

3fill in blank

hard

Fix the error in the outer loop condition to run bubble sort correctly.

DSA C++

for (int i = 0; i < [1]; i++) {
    // inner loop
}

Drag options to blanks, or click blank then click option'

An-1

Bn

Cn+1

Dn/2

Attempts:

3 left

💡 Hint

Common Mistakes

Using n causes one extra pass.

Using n/2 is incorrect for bubble sort passes.

The outer loop runs n-1 times because after n-1 passes, the array is sorted.

4fill in blank

hard

Fill both blanks to complete the bubble sort inner loop swap condition and swap code.

DSA C++

if (arr[[1]] > arr[[2]]) {
    int temp = arr[[1]];
    arr[[1]] = arr[[2]];
    arr[[2]] = temp;
}

Drag options to blanks, or click blank then click option'

Aj

Bj+1

Ci

Di+1

Attempts:

3 left

💡 Hint

Common Mistakes

Using i instead of j in the inner loop swap.

Swapping wrong indices causing incorrect sorting.

We compare arr[j] with arr[j+1] and swap if arr[j] is greater to bubble the largest element up.

5fill in blank

hard

Fill all three blanks to complete the full bubble sort function.

DSA C++

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < [1]; i++) {
        for (int j = 0; j < n - i - [2]; j++) {
            if (arr[j] > arr[j + [3]]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

Drag options to blanks, or click blank then click option'

An-1

B1

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong loop limits causing out of bounds errors.

Incorrect indices in comparison leading to wrong sorting.

The outer loop runs n-1 times, inner loop runs n - i - 1 times, and we compare arr[j] with arr[j+1].

Practice

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

easy

A. Divide the array into halves and sort each half separately

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

C. Select the smallest element and move it to the beginning

D. Insert each element into its correct position in a sorted part

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: Identify the correct description

   This swapping of neighbors repeats until the whole list is sorted.

3. Final Answer:

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

4. Quick Check:

   Bubble Sort = Swap neighbors repeatedly [OK]

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

Common Mistakes:

• Confusing Bubble Sort with Selection Sort
• Thinking it divides the array like Merge Sort
• Assuming it inserts elements like Insertion Sort

2. Which of the following is the correct syntax for the inner loop of Bubble Sort in C++ to compare adjacent elements in an array arr of size n?

easy

A. for (int j = 0; j < n - i - 1; j++)

B. for (int j = 0; j < n; j++)

C. for (int j = 1; j < n - i; j++)

D. for (int j = 0; j <= n - i; j++)

Solution

1. Step 1: Understand inner loop range

   The inner loop runs from 0 to n - i - 1 because after each pass, the last i elements are sorted.

2. Step 2: Check each option

   for (int j = 0; j < n - i - 1; j++) correctly uses j < n - i - 1 to avoid out-of-bound and unnecessary comparisons.

3. Final Answer:

   for (int j = 0; j < n - i - 1; j++) -> Option A

4. Quick Check:

   Inner loop limit = n - i - 1 [OK]

Hint: Inner loop stops before sorted elements at end [OK]

Common Mistakes:

• Using j < n instead of j < n - i - 1
• Starting j from 1 instead of 0
• Using <= instead of < causing out-of-bound

3. What will be the output of the following C++ code snippet?

int arr[] = {5, 3, 8, 4};
int n = 4;
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;
    }
  }
}
for (int i = 0; i < n; i++) {
  std::cout << arr[i] << " ";
}

medium

A. 3 5 4 8

B. 5 3 4 8

C. 8 5 4 3

D. 3 4 5 8

Solution

1. Step 1: Trace first pass of Bubble Sort

   Compare pairs: (5,3) swap -> {3,5,8,4}, (5,8) no swap, (8,4) swap -> {3,5,4,8}

2. Step 2: Trace second pass and final array

   Next pass: (3,5) no swap, (5,4) swap -> {3,4,5,8}, last pass no swaps needed.

3. Final Answer:

   3 4 5 8 -> Option D

4. Quick Check:

   Sorted array = 3 4 5 8 [OK]

Hint: Bubble Sort pushes largest to end each pass [OK]

Common Mistakes:

• Not swapping correctly on first pass
• Confusing order of swaps
• Printing unsorted array

4. Identify the error in the following Bubble Sort code snippet and select the correct fix:

void bubbleSort(int arr[], int n) {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n - i; j++) {
      if (arr[j] > arr[j + 1]) {
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
}

medium

A. Add a swap flag to optimize and stop early if sorted

B. Change outer loop to i < n - 1 to reduce unnecessary passes

C. Change inner loop to j < n - i - 1 to avoid out-of-bound access

D. No error, code is correct

Solution

1. Step 1: Analyze inner loop condition

   Inner loop uses j < n - i, but accesses arr[j + 1], which causes out-of-bound when j = n - i - 1.

2. Step 2: Correct inner loop limit

   Changing to j < n - i - 1 prevents accessing arr[n], fixing runtime error.

3. Final Answer:

   Change inner loop to j < n - i - 1 to avoid out-of-bound access -> Option C

4. Quick Check:

   Inner loop limit fixes out-of-bound [OK]

Hint: Inner loop must stop before last compared index [OK]

Common Mistakes:

• Ignoring out-of-bound access
• Changing outer loop only
• Assuming code is correct without checking array access

5. Given an array arr = {7, 2, 9, 4, 3}, how many total swaps will Bubble Sort perform to sort it in ascending order?

hard

A. 6

B. 5

C. 4

D. 7

Solution

1. Step 1: Trace swaps in each pass

   Pass 1: (7,2) swap, (7,9) no, (9,4) swap, (9,3) swap -> 3 swaps
   Array now: {2,7,4,3,9}

2. Step 2: Continue tracing swaps

   Pass 2: (2,7) no, (7,4) swap, (7,3) swap -> 2 swaps
   Array now: {2,4,3,7,9}
   Pass 3: (2,4) no, (4,3) swap -> 1 swap
   Array now: {2,3,4,7,9}
   Pass 4: no swaps

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Total swaps counted = 6 [OK]

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

Common Mistakes:

• Counting comparisons instead of swaps
• Stopping early without counting all passes
• Miscounting swaps in passes