refactor: simplify assign minIndex in recursiveSelectionSort, and improving SelectionSort

Author: Alex Klymenko

src/main/java/com/thealgorithms/sorts/SelectionSort.java

@@ -1,9 +1,5 @@
 package com.thealgorithms.sorts;
 
-/**
- * This class provides an implementation of the selection sort algorithm.
- * It sorts an array of elements in increasing order using an iterative approach.
- */
 public class SelectionSort implements SortAlgorithm {
     /**
      * Sorts an array of comparable elements in increasing order using the selection sort algorithm.
@@ -14,25 +10,22 @@ public class SelectionSort implements SortAlgorithm {
      */
     @Override
     public <T extends Comparable<T>> T[] sort(T[] array) {
-        if (array.length == 0) {
-            return array;
-        }
-
         // One by one move the boundary of the unsorted subarray
         for (int i = 0; i < array.length - 1; i++) {
-            // Find the minimum element in the unsorted array
-            int minIndex = i;
-            for (int j = i + 1; j < array.length; j++) {
-                if (array[j].compareTo(array[minIndex]) < 0) {
-                    minIndex = j;
-                }
-            }
 
-            // Swap the found minimum element with the first element
-            if (minIndex != i) {
-                SortUtils.swap(array, i, minIndex);
-            }
+            // Swap the remaining minimum element with the current element
+            SortUtils.swap(array, i, findIndexOfMin(array, i));
         }
         return array;
     }
-}
+
+    private static <T extends Comparable<T>> int findIndexOfMin(T[] array, final int start) {
+        int minIndex = start;
+        for (int i = start + 1; i < array.length; i++) {
+            if (array[i].compareTo(array[minIndex]) < 0) {
+                minIndex = i;
+            }
+        }
+        return minIndex;
+    }
+}

src/main/java/com/thealgorithms/sorts/SelectionSortRecursive.java

@@ -32,13 +32,7 @@ private static <T extends Comparable<T>> void recursiveSelectionSort(T[] array,
             return;
         }
 
-        // Find the minimum element in the remaining unsorted array
-        final int minIndex = findMinIndex(array, index);
-
-        // Swap the found minimum element with the element at the current index
-        if (minIndex != index) {
-            SortUtils.swap(array, index, minIndex);
-        }
+        SortUtils.swap(array, index, findMinIndex(array, index));
 
         // Recursively call selection sort for the remaining array
         recursiveSelectionSort(array, index + 1);