Bubble Sort Algorithm in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Bubble Sort code?

Consider the following JavaScript code that sorts an array using Bubble Sort. What will be the printed output after running this code?

DSA Javascript

const arr = [5, 3, 8, 4, 2];
for (let i = 0; i < arr.length - 1; i++) {
  for (let j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] > arr[j + 1]) {
      const temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}
console.log(arr.join(' -> ') + ' -> null');

A 5 -> 3 -> 8 -> 4 -> 2 -> null

B 2 -> 3 -> 4 -> 5 -> 8 -> null

C 8 -> 5 -> 4 -> 3 -> 2 -> null

D 2 -> 4 -> 3 -> 5 -> 8 -> null

💡 Hint

Remember Bubble Sort swaps adjacent elements if they are in the wrong order, pushing the largest to the end each pass.

Bubble Sort compares pairs and swaps them if needed, so the largest numbers move to the right. After all passes, the array is sorted ascending: 2, 3, 4, 5, 8.

🧠 Conceptual

intermediate

How many total swaps does Bubble Sort perform on this array?

Given the array [4, 2, 7, 3], how many swaps will Bubble Sort perform to sort it in ascending order?

A 6

B 4

C 3

D 5

💡 Hint

Count each time two adjacent elements are swapped during the sorting process.

Initial: [4,2,7,3] Pass 1: swap 4 and 2 → [2,4,7,3], swap 7 and 3 → [2,4,3,7] (2 swaps) Pass 2: swap 4 and 3 → [2,3,4,7] (1 swap) Pass 3: no swaps Total swaps = 3.

❓ Predict Output

advanced

What error does this Bubble Sort code produce?

Analyze the following Bubble Sort code snippet. What error will it raise when run?

DSA Javascript

const arr = [3, 1, 4];
for (let i = 0; i <= arr.length; i++) {
  for (let j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] > arr[j + 1]) {
      [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
    }
  }
}
console.log(arr.join(' -> ') + ' -> null');

A No error, outputs: 1 -> 3 -> 4 -> null

B RangeError: Maximum call stack size exceeded

C TypeError: Cannot read property 'length' of undefined

D undefined -> undefined -> undefined -> null

💡 Hint

Check the loop conditions carefully for off-by-one errors causing undefined access.

The outer loop runs from i=0 to i=3 (arr.length=3). When i=3, inner loop j < -1 does not run. No invalid array access occurs. The array is sorted correctly to [1,3,4] with no error.

🔧 Debug

advanced

Identify the bug in this Bubble Sort implementation

This Bubble Sort code is intended to sort an array ascending but produces incorrect output. What is the bug?

DSA Javascript

const arr = [6, 2, 9, 1];
for (let i = 0; i < arr.length; i++) {
  for (let j = 0; j < arr.length - 1; j++) {
    if (arr[j] < arr[j + 1]) {
      const temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}
console.log(arr.join(' -> ') + ' -> null');

A The outer loop should run from arr.length - 1 down to 0

B The inner loop should run fewer times each pass to avoid unnecessary comparisons

C The temporary variable is not used correctly causing wrong swaps

D The comparison operator should be '>' to sort ascending, not '<'

💡 Hint

Check the comparison direction to see if it sorts ascending or descending.

The code uses 'arr[j] < arr[j + 1]' which swaps if left is less than right, causing descending order. To sort ascending, it should be 'arr[j] > arr[j + 1]'.

🚀 Application

expert

How many passes does Bubble Sort need to sort this array?

Given the array [1, 2, 3, 4, 5], how many passes (outer loop iterations) will Bubble Sort perform before it stops if optimized to stop early when no swaps occur?

DSA Javascript

const arr = [1, 2, 3, 4, 5];
let n = arr.length;
for (let i = 0; i < n; i++) {
  let swapped = false;
  for (let j = 0; j < n - 1 - i; j++) {
    if (arr[j] > arr[j + 1]) {
      [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      swapped = true;
    }
  }
  if (!swapped) break;
}
console.log(arr.join(' -> ') + ' -> null');

A 1

B 4

C 5

D 0

💡 Hint

If the array is already sorted, the algorithm stops after the first pass with no swaps.

Since the array is already sorted, no swaps happen in the first pass, so the loop breaks immediately after 1 pass.

Practice

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

easy

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

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

C. Select the smallest element and place it at the beginning

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

Solution

1. Step 1: Understand Bubble Sort mechanism

   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: selection sort (A), divide and conquer (B), insertion sort (D).

3. Final Answer:

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

4. Quick Check:

   Bubble Sort = swapping adjacent pairs [OK]

Hint: Bubble Sort swaps neighbors repeatedly to sort [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 to swap two elements arr[i] and arr[i+1] in JavaScript during Bubble Sort?

easy

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

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

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

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

Solution

1. Step 1: Understand JavaScript swapping

   JavaScript does not support tuple unpacking; use a temporary variable to swap.

2. Step 2: Analyze each option

   let temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; uses a temp variable correctly. arr[i], arr[i+1] = arr[i+1], arr[i]; is Python syntax, invalid in JS. swap(arr[i], arr[i+1]); calls undefined function. arr[i] = arr[i+1]; arr[i+1] = arr[i]; overwrites values incorrectly.

3. Final Answer:

   let temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; -> Option D

4. Quick Check:

   Use temp variable to swap in JS [OK]

Hint: Use temp variable to swap in JavaScript [OK]

Common Mistakes:

• Using Python-style tuple swap in JavaScript
• Calling undefined swap function
• Overwriting values without temp variable

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

let arr = [4, 2, 3];
for(let i = 0; i < arr.length - 1; i++) {
  if(arr[i] > arr[i+1]) {
    let temp = arr[i];
    arr[i] = arr[i+1];
    arr[i+1] = temp;
  }
}
console.log(arr);

medium

A. [2, 4, 3]

B. [2, 3, 4]

C. [4, 2, 3]

D. [3, 2, 4]

Solution

1. Step 1: Trace the single pass of the loop

   Loop runs i=0 to 1. At i=0: 4 > 2, swap -> arr = [2,4,3]. At i=1: 4 > 3, swap -> arr = [2,3,4].

2. Step 2: Check loop range carefully

   The loop runs only once over the array (i from 0 to length-2). So swaps happen at i=0 and i=1.

3. Final Answer:

   [2, 4, 3] -> Option A

4. Quick Check:

   One pass swaps neighbors to partially sort [OK]

Hint: Trace each swap carefully for one loop pass [OK]

Common Mistakes:

• Assuming full sort after one pass
• Ignoring second swap at i=1
• Confusing array indices

4. Identify the error in this Bubble Sort code snippet and choose the correct fix:

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

medium

A. Remove the inner loop completely

B. Change outer loop to run from i = 1 to arr.length

C. Change inner loop condition to j < arr.length - i - 1

D. Add a check to skip swapping equal elements

Solution

1. Step 1: Analyze inner loop range

   Inner loop runs till j < arr.length, so arr[j+1] can be undefined at last index causing error.

2. Step 2: Fix inner loop to avoid out-of-bound access

   Changing condition to j < arr.length - i - 1 prevents accessing beyond array length and optimizes sorting.

3. Final Answer:

   Change inner loop condition to j < arr.length - i - 1 -> Option C

4. Quick Check:

   Inner loop must avoid out-of-bound index [OK]

Hint: Inner loop stops earlier each pass to avoid overflow [OK]

Common Mistakes:

• Ignoring array boundary causing undefined access
• Changing outer loop incorrectly
• Removing inner loop breaks sorting

5. Given the array [5, 1, 4, 2, 8], how many total swaps will Bubble Sort perform to fully sort it in ascending order?

hard

A. 4

B. 6

C. 5

D. 7

Solution

1. Step 1: Perform Bubble Sort passes and count swaps

   Pass 1 swaps: (5,1), (5,4), (5,2) -> 3 swaps (5 and 8 no swap).

2. Step 2: Continue passes counting swaps

   Pass 2 swaps: (4,2) -> 1 swap. Pass 3 swaps: (4,3) none here but actually (2,3) no swap, but we need to check carefully. Actually, pass 3 swaps: (2,3) no swap, pass 4 no swaps. Total swaps: 3 + 1 + 2 = 6.

3. Step 3: Verify total swaps

   Counting carefully, total swaps are 6, so 6.

4. Final Answer:

   6 -> Option B

5. Quick Check:

   Count swaps each pass carefully [OK]

Hint: Count swaps pass by pass to avoid missing any [OK]

Common Mistakes:

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