feat: add SelectionSortRecursive (#5255)

* Implementation: SelectionSort using recursion

* Documentation: adding links

* Fix issue with findMinIndex

* Fix: change findMinIndex method to recursive

* Fix: improve variable change scope

* Fix: Replacing recursive method findMinIndex with iterative. To fix StackOverFlow on huge arrays

* refactor: remove `null` check

* Fix: Removing redundant null check

---------

Co-authored-by: alxklm <alx@alx.com>
Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com>

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

@@ -0,0 +1,66 @@
+package com.thealgorithms.sorts;
+
+/**
+ * Class that implements the Selection Sort algorithm using recursion.
+ */
+public class SelectionSortRecursive implements SortAlgorithm {
+
+    /**
+     * Sorts an array using recursive selection sort.
+     *
+     * @param array the array to be sorted
+     * @param <T>   the type of elements in the array (must be Comparable)
+     * @return the sorted array
+     */
+    public <T extends Comparable<T>> T[] sort(T[] array) {
+        if (array.length == 0) {
+            return array;
+        }
+        recursiveSelectionSort(array, 0);
+        return array;
+    }
+
+    /**
+     * Recursively sorts the array using selection sort.
+     *
+     * @param array the array to be sorted
+     * @param index the current index to start sorting from
+     * @param <T>   the type of elements in the array (must be Comparable)
+     */
+    private static <T extends Comparable<T>> void recursiveSelectionSort(T[] array, int index) {
+        if (index == array.length - 1) {
+            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);
+        }
+
+        // Recursively call selection sort for the remaining array
+        recursiveSelectionSort(array, index + 1);
+    }
+
+    /**
+     * Finds the index of the minimum element in the array starting from the given index.
+     *
+     * @param array the array to search in.
+     * @param start the starting index.
+     * @param <T> the type of the elements in the array, which must be Comparable.
+     * @return the index of the minimum element starting from the given index.
+     */
+    private static <T extends Comparable<T>> int findMinIndex(T[] array, int start) {
+        int currentMinIndex = start;
+
+        for (int currentIndex = start + 1; currentIndex < array.length; currentIndex++) {
+            if (array[currentIndex].compareTo(array[currentMinIndex]) < 0) {
+                currentMinIndex = currentIndex;
+            }
+        }
+
+        return currentMinIndex;
+    }
+}