Selection Sort Algorithm in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of selection sort on this array?

Given the array [29, 10, 14, 37, 13], what will be the array after the first two passes of selection sort?

DSA Javascript

const arr = [29, 10, 14, 37, 13];

// After first pass
// After second pass

// What is arr now?

A [10, 14, 13, 29, 37]

B [10, 13, 14, 29, 37]

C [10, 14, 13, 37, 29]

D [10, 13, 14, 37, 29]

💡 Hint

Selection sort picks the smallest element and swaps it with the current position.

First pass swaps 29 with 10: [10, 29, 14, 37, 13]. Second pass swaps 29 with 13: [10, 13, 14, 37, 29].

🧠 Conceptual

intermediate

How many swaps does selection sort perform on an array of length n?

Consider selection sort on an array of length n. How many swaps does it perform in the worst case?

A 0 swaps

B n swaps

C n*(n-1)/2 swaps

D n-1 swaps

💡 Hint

Selection sort swaps only once per pass after finding the minimum.

Selection sort performs exactly n-1 swaps because it swaps the smallest element into place once per pass.

❓ Predict Output

advanced

What is the final sorted array after running this selection sort code?

Given the code below, what is the final printed array?

DSA Javascript

function selectionSort(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    if (minIndex !== i) {
      [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
    }
  }
  return arr;
}

const result = selectionSort([64, 25, 12, 22, 11]);
console.log(result);

A [11, 12, 22, 25, 64]

B [64, 25, 12, 22, 11]

C [11, 22, 12, 25, 64]

D [12, 11, 22, 25, 64]

💡 Hint

Selection sort sorts the array in ascending order by repeatedly selecting the smallest element.

The code correctly implements selection sort, resulting in the sorted array [11, 12, 22, 25, 64].

🔧 Debug

advanced

What error does this selection sort code produce?

Consider this code snippet. What error will it raise when run?

DSA Javascript

function selectionSort(arr) {
  for (let i = 0; i <= arr.length; i++) {
    let minIndex = i;
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
  }
  return arr;
}

selectionSort([3, 1, 2]);

A TypeError: Cannot destructure property of undefined

B RangeError: Maximum call stack size exceeded

C TypeError: Cannot read property 'length' of undefined

D undefined is not a function

💡 Hint

Check the loop condition for i and how it affects array access.

The loop runs with i = arr.length, causing arr[i] to be undefined. Destructuring swap fails with TypeError.

🧠 Conceptual

expert

What is the time complexity of selection sort and why?

Select the correct time complexity of selection sort and the reason behind it.

A O(n) because it only swaps elements once per pass

B O(n log n) because it divides the array and merges sorted parts

C O(n^2) because it uses nested loops to find the minimum element for each position

D O(log n) because it uses binary search to find the minimum

💡 Hint

Think about how many comparisons selection sort makes in total.

Selection sort uses two nested loops, each running up to n times, resulting in O(n^2) time complexity.

Practice

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

easy

A. Divide the array into halves and merge sorted halves

B. Repeatedly find the smallest element and move it to the front

C. Swap adjacent elements if they are in wrong order repeatedly

D. Use a pivot to partition the array into smaller parts

Solution

1. Step 1: Understand Selection Sort process

   Selection Sort works by finding the smallest element in the unsorted part and swapping it with the first unsorted element.

2. Step 2: Compare with other sorting methods

   Other options describe Merge Sort, Bubble Sort, and Quick Sort, which are different algorithms.

3. Final Answer:

   Repeatedly find the smallest element and move it to the front -> Option B

4. Quick Check:

   Selection Sort = Find smallest and swap [OK]

Hint: Selection Sort always picks the smallest next element [OK]

Common Mistakes:

• Confusing Selection Sort with Bubble Sort
• Thinking it uses divide and conquer
• Assuming it uses a pivot element

2. Which of the following is the correct syntax to swap two elements arr[i] and arr[minIndex] in JavaScript during Selection Sort?

easy

A. temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp;

B. arr[i], arr[minIndex] = arr[minIndex], arr[i];

C. [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];

D. swap(arr[i], arr[minIndex]);

Solution

1. Step 1: Identify JavaScript swap syntax

   JavaScript supports swapping using destructuring assignment: [a, b] = [b, a].

2. Step 2: Check each option

   temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp; is valid but missing let or var for temp and is verbose. arr[i], arr[minIndex] = arr[minIndex], arr[i]; is invalid syntax in JavaScript. swap(arr[i], arr[minIndex]); is a function call but no such built-in function exists.

3. Final Answer:

   [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]; -> Option C

4. Quick Check:

   Destructuring swap = [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]; [OK]

Hint: Use destructuring assignment for swapping in JavaScript [OK]

Common Mistakes:

• Using Python-style tuple swap syntax
• Calling undefined swap function
• Forgetting to declare temporary variable

3. What will be the output array after running Selection Sort on [29, 10, 14, 37, 13]?

medium

A. [37, 29, 14, 13, 10]

B. [13, 10, 14, 29, 37]

C. [29, 10, 14, 37, 13]

D. [10, 13, 14, 29, 37]

Solution

1. Step 1: Perform Selection Sort step-by-step

   Initial array: [29, 10, 14, 37, 13]
   Find smallest from index 0 to end: 10 at index 1, swap with 29.
   Array: [10, 29, 14, 37, 13]
   Find smallest from index 1 to end: 13 at index 4, swap with 29.
   Array: [10, 13, 14, 37, 29]
   Find smallest from index 2 to end: 14 at index 2, no swap.
   Find smallest from index 3 to end: 29 at index 4, swap with 37.
   Array: [10, 13, 14, 29, 37]

2. Step 2: Confirm final sorted array

   The array is sorted in ascending order: [10, 13, 14, 29, 37].

3. Final Answer:

   [10, 13, 14, 29, 37] -> Option D

4. Quick Check:

   Sorted array = [10, 13, 14, 29, 37] [OK]

Hint: Selection Sort places smallest element at front each pass [OK]

Common Mistakes:

• Not swapping correctly after finding minimum
• Confusing index positions during swaps
• Assuming array is unchanged

4. Identify the error in this Selection Sort code snippet:

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

medium

A. Swapping lines overwrite values causing incorrect swaps

B. Loop ranges are incorrect, should be j < arr.length - 1

C. minIndex should be initialized outside the outer loop

D. Function does not return the sorted array

Solution

1. Step 1: Analyze the swap logic

   The swap is done by assigning arr[i] = arr[minIndex] first, then arr[minIndex] = arr[i]. This overwrites arr[i] before assigning to arr[minIndex], causing both to have the same value.

2. Step 2: Correct swap method

   Use a temporary variable or destructuring assignment to swap without overwriting:
   let temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp;

3. Final Answer:

   Swapping lines overwrite values causing incorrect swaps -> Option A

4. Quick Check:

   Incorrect swap overwrites values = Swapping lines overwrite values causing incorrect swaps [OK]

Hint: Use temp variable or destructuring to swap safely [OK]

Common Mistakes:

• Swapping without temp variable
• Incorrect loop boundaries
• Not returning the array

5. Given an array with duplicate values [4, 2, 4, 3, 2], how many swaps will Selection Sort perform to fully sort it?

hard

A. 3

B. 5

C. 4

D. 2

Solution

1. Step 1: Trace Selection Sort swaps on the array

   Initial array: [4, 2, 4, 3, 2]
   Pass 1: smallest from index 0-4 is 2 at index 1, swap with 4 at index 0.
   Array: [2, 4, 4, 3, 2] (1 swap)
   Pass 2: smallest from index 1-4 is 2 at index 4, swap with 4 at index 1.
   Array: [2, 2, 4, 3, 4] (2 swaps)
   Pass 3: smallest from index 2-4 is 3 at index 3, swap with 4 at index 2.
   Array: [2, 2, 3, 4, 4] (3 swaps)
   Pass 4: smallest from index 3-4 is 4 at index 3, no swap.
   Pass 5: last element, no swap.

2. Step 2: Count total swaps

   Total swaps performed = 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Count swaps during passes = 3 [OK]

Hint: Count swaps only when minimum index differs from current index [OK]

Common Mistakes:

• Counting all comparisons as swaps
• Ignoring swaps when minIndex equals current index
• Assuming duplicates reduce swaps to zero