Refactoring and code improving for StrandSort (#5243)

* Refactoring and code improving for StrandSort

* Fix java checkstyle

* Fix "Each variable declaration must be in its own statement"

* Fix "uses integer based for loops to iterate over a List"

---------

Co-authored-by: alx <alx@alx.com>

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

@@ -1,46 +1,79 @@
 package com.thealgorithms.sorts;
 
-import java.util.Iterator;
+import java.util.ArrayList;
-import java.util.LinkedList;
+import java.util.Arrays;
+import java.util.List;
 
-public final class StrandSort {
+/**
-    private StrandSort() {
+ * StrandSort class implementing the SortAlgorithm interface using arrays.
+ */
+public final class StrandSort implements SortAlgorithm {
+
+    /**
+     * Sorts the given array using the Strand Sort algorithm.
+     *
+     * @param <T> The type of elements to be sorted, must be Comparable.
+     * @param unsorted The array to be sorted.
+     * @return The sorted array.
+     */
+    @Override
+    public <T extends Comparable<T>> T[] sort(T[] unsorted) {
+        List<T> unsortedList = new ArrayList<>(Arrays.asList(unsorted));
+        List<T> sortedList = strandSort(unsortedList);
+        return sortedList.toArray(unsorted);
     }
 
-    // note: the input list is destroyed
+    /**
-    public static <E extends Comparable<? super E>> LinkedList<E> strandSort(LinkedList<E> list) {
+     * Strand Sort algorithm that sorts a list.
+     *
+     * @param <T> The type of elements to be sorted, must be Comparable.
+     * @param list The list to be sorted.
+     * @return The sorted list.
+     */
+    private static <T extends Comparable<? super T>> List<T> strandSort(List<T> list) {
         if (list.size() <= 1) {
             return list;
         }
 
-        LinkedList<E> result = new LinkedList<E>();
+        List<T> result = new ArrayList<>();
-        while (list.size() > 0) {
+        while (!list.isEmpty()) {
-            LinkedList<E> sorted = new LinkedList<E>();
+            final List<T> sorted = new ArrayList<>();
-            sorted.add(list.removeFirst()); // same as remove() or remove(0)
+            sorted.add(list.remove(0));
-            for (Iterator<E> it = list.iterator(); it.hasNext();) {
+            for (int i = 0; i < list.size();) {
-                E elem = it.next();
+                if (sorted.get(sorted.size() - 1).compareTo(list.get(i)) <= 0) {
-                if (sorted.peekLast().compareTo(elem) <= 0) {
+                    sorted.add(list.remove(i));
-                    sorted.addLast(elem); // same as add(elem) or add(0, elem)
+                } else {
-                    it.remove();
+                    i++;
                 }
             }
-            result = merge(sorted, result);
+            result = merge(result, sorted);
         }
         return result;
     }
 
-    private static <E extends Comparable<? super E>> LinkedList<E> merge(LinkedList<E> left, LinkedList<E> right) {
+    /**
-        LinkedList<E> result = new LinkedList<E>();
+     * Merges two sorted lists into one sorted list.
-        while (!left.isEmpty() && !right.isEmpty()) {
+     *
-            // change the direction of this comparison to change the direction of the sort
+     * @param <T> The type of elements to be sorted, must be Comparable.
-            if (left.peek().compareTo(right.peek()) <= 0) {
+     * @param left The first sorted list.
-                result.add(left.remove());
+     * @param right The second sorted list.
+     * @return The merged sorted list.
+     */
+    private static <T extends Comparable<? super T>> List<T> merge(List<T> left, List<T> right) {
+        List<T> result = new ArrayList<>();
+        int i = 0;
+        int j = 0;
+        while (i < left.size() && j < right.size()) {
+            if (left.get(i).compareTo(right.get(j)) <= 0) {
+                result.add(left.get(i));
+                i++;
             } else {
-                result.add(right.remove());
+                result.add(right.get(j));
+                j++;
             }
         }
-        result.addAll(left);
+        result.addAll(left.subList(i, left.size()));
-        result.addAll(right);
+        result.addAll(right.subList(j, right.size()));
         return result;
     }
 }

src/test/java/com/thealgorithms/sorts/StrandSortTest.java

@@ -1,34 +1,8 @@
 package com.thealgorithms.sorts;
 
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+class StrandSortTest extends SortingAlgorithmTest {
-
+    @Override
-import java.util.Arrays;
+    SortAlgorithm getSortAlgorithm() {
-import java.util.LinkedList;
+        return new StrandSort();
-import org.junit.jupiter.api.Test;
-
-class StrandSortTest {
-
-    @Test
-    // valid test case
-    public void strandSortNonDuplicateTest() {
-        int[] expectedArray = {1, 2, 3, 4, 5};
-        LinkedList<Integer> actualList = StrandSort.strandSort(new LinkedList<Integer>(Arrays.asList(3, 1, 2, 4, 5)));
-        int[] actualArray = new int[actualList.size()];
-        for (int i = 0; i < actualList.size(); i++) {
-            actualArray[i] = actualList.get(i);
-        }
-        assertArrayEquals(expectedArray, actualArray);
-    }
-
-    @Test
-    // valid test case
-    public void strandSortDuplicateTest() {
-        int[] expectedArray = {2, 2, 2, 5, 7};
-        LinkedList<Integer> actualList = StrandSort.strandSort(new LinkedList<Integer>(Arrays.asList(7, 2, 2, 2, 5)));
-        int[] actualArray = new int[actualList.size()];
-        for (int i = 0; i < actualList.size(); i++) {
-            actualArray[i] = actualList.get(i);
-        }
-        assertArrayEquals(expectedArray, actualArray);
     }
 }