Selection Sort Algorithm in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Selection Sort on a small array

What is the output of the following Java code after running selection sort on the array?

DSA Java

public class Main {
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }

    public static void main(String[] args) {
        int[] data = {64, 25, 12, 22, 11};
        selectionSort(data);
        for (int num : data) {
            System.out.print(num + " ");
        }
    }
}

A 11 12 22 25 64

B 64 25 12 22 11

C 25 12 22 11 64

D 11 22 12 25 64

💡 Hint

Selection sort finds the smallest element and puts it at the start, then repeats for the rest.

Selection sort repeatedly selects the smallest remaining element and swaps it to the front. After sorting, the array is in ascending order: 11 12 22 25 64.

🧠 Conceptual

intermediate

Number of swaps in selection sort

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

A 0 swaps

B n swaps

C n - 1 swaps

D n * (n - 1) / 2 swaps

💡 Hint

Selection sort swaps only once per outer loop iteration.

Selection sort performs exactly one swap per outer loop iteration, so for n elements, it does n-1 swaps in the worst case.

🔧 Debug

advanced

Identify the bug in this selection sort code

What error will this Java code cause when running selection sort?

DSA Java

public static void selectionSort(int[] arr) {
    for (int i = 0; i <= arr.length; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

A Infinite loop

B NullPointerException

C No error, runs correctly

D ArrayIndexOutOfBoundsException

💡 Hint

Check the loop condition for i carefully.

The outer loop uses i <= arr.length which causes i to go out of array bounds, leading to ArrayIndexOutOfBoundsException.

❓ Predict Output

advanced

Selection sort on a reversed array

What is the output after running selection sort on this array?

DSA Java

public class Main {
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }

    public static void main(String[] args) {
        int[] data = {5, 4, 3, 2, 1};
        selectionSort(data);
        for (int num : data) {
            System.out.print(num + " ");
        }
    }
}

A 1 3 2 4 5

B 1 2 3 4 5

C 5 4 3 2 1

D 2 1 3 4 5

💡 Hint

Selection sort always sorts the array in ascending order.

Selection sort finds the smallest element and places it at the start repeatedly, so the reversed array becomes sorted ascending: 1 2 3 4 5.

🧠 Conceptual

expert

Time complexity of selection sort

What is the time complexity of selection sort in all cases (best, average, worst)?

A O(n^2) for all cases

B O(n log n) best, O(n^2) worst

C O(n) best, O(n^2) worst

D O(n^2) best, O(n) worst

💡 Hint

Selection sort always scans the entire unsorted part to find the minimum.

Selection sort always does nested loops over the array, so it takes O(n^2) time no matter the input.

Practice

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

easy

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

B. Divide the list into halves and sort each half recursively

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

D. Use a heap data structure to sort elements efficiently

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

   Unlike divide and conquer or adjacent swaps, Selection Sort directly selects the minimum each time.

3. Final Answer:

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

4. Quick Check:

   Selection Sort = Find min and swap [OK]

Hint: Selection Sort picks smallest element each pass [OK]

Common Mistakes:

• Confusing Selection Sort with Bubble Sort
• Thinking it divides the list recursively
• Assuming it uses extra data structures

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

easy

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

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

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

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

Solution

1. Step 1: Understand Java swap syntax

   Java does not have a built-in swap function; we use a temporary variable to swap values.

2. Step 2: Check each option

   temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp; correctly uses a temporary variable. arr[i] = arr[minIndex]; arr[minIndex] = arr[i]; overwrites arr[i] before saving it. swap(arr[i], arr[minIndex]); is invalid syntax. arr[i], arr[minIndex] = arr[minIndex], arr[i]; is Python style, not Java.

3. Final Answer:

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

4. Quick Check:

   Use temp variable to swap in Java [OK]

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

Common Mistakes:

• Trying to swap without temp variable
• Using Python or other language syntax
• Overwriting one element before saving it

3. What will be the output array after running Selection Sort on int[] arr = {29, 10, 14, 37, 13};?

medium

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

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

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

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

Solution

1. Step 1: Perform first pass to find minimum

   Minimum is 10, swap with 29: [10, 29, 14, 37, 13]

2. Step 2: Perform second pass to find next minimum

   Minimum in remaining is 13, swap with 29: [10, 13, 14, 37, 29]

3. Step 3: Continue sorting

   Next minimum is 14 (already in place), then 29 and 37 sorted: [10, 13, 14, 29, 37]

4. Final Answer:

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

5. Quick Check:

   Selection Sort output = sorted array [OK]

Hint: Selection Sort outputs sorted array ascending [OK]

Common Mistakes:

• Not swapping correctly after finding minimum
• Confusing indices during swaps
• Stopping sorting early

4. Consider this buggy Selection Sort snippet:

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

What is the error?

medium

A. The inner loop condition should be j <= arr.length

B. The comparison should be arr[j] < arr[minIndex] to find minimum

C. The swap is done before finding minimum

D. The outer loop should start from 1 instead of 0

Solution

1. Step 1: Analyze the comparison in inner loop

   The code uses arr[j] > arr[minIndex], which finds the maximum, not minimum.

2. Step 2: Correct the comparison for Selection Sort

   Selection Sort requires finding the minimum, so comparison should be arr[j] < arr[minIndex].

3. Final Answer:

   The comparison should be arr[j] < arr[minIndex] to find minimum -> Option B

4. Quick Check:

   Selection Sort finds minimum, so use < comparison [OK]

Hint: Use less than to find minimum in Selection Sort [OK]

Common Mistakes:

• Using greater than instead of less than
• Changing loop bounds incorrectly
• Swapping before finding minimum

5. You want to sort an array but only partially: after Selection Sort runs for 2 passes on int[] arr = {20, 5, 15, 10, 25}, what is the array state?

hard

A. [5, 10, 15, 25, 20]

B. [5, 10, 15, 20, 25]

C. [5, 15, 10, 20, 25]

D. [5, 15, 10, 25, 20]

Solution

1. Step 1: First pass finds minimum

   Minimum is 5, swap with 20: [5, 20, 15, 10, 25]

2. Step 2: Second pass finds next minimum in remaining

   Minimum in [20, 15, 10, 25] is 10, swap with 20: [5, 10, 15, 20, 25]

3. Step 3: Array after 2 passes

   Array is [5, 10, 15, 20, 25]

4. Final Answer:

   [5, 10, 15, 25, 20] -> Option A

5. Quick Check:

   Two passes partially sort array [OK]

Hint: Each pass places one smallest element correctly [OK]

Common Mistakes:

• Not swapping correctly after each pass
• Confusing which elements are sorted
• Assuming full sort after 2 passes