Refactoring and code improving for OddEvenSort, changing it according to SortAlgorithm approach, also applying SortUtils

Author: alx

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

@@ -2,68 +2,62 @@
 
 import java.util.Random;
 
-// https://en.wikipedia.org/wiki/Odd%E2%80%93even_sort
-public final class OddEvenSort {
-    private OddEvenSort() {
-    }
-
-    public static void main(String[] args) {
-        int[] arr = new int[100];
-
-        Random random = new Random();
-
-        // Print out unsorted elements
-        for (int i = 0; i < arr.length; ++i) {
-            arr[i] = random.nextInt(100) - 50;
-            System.out.println(arr[i]);
-        }
-        System.out.println("--------------");
-
-        oddEvenSort(arr);
-
-        // Print Sorted elements
-        for (int i = 0; i < arr.length - 1; ++i) {
-            System.out.println(arr[i]);
-            assert arr[i] <= arr[i + 1];
-        }
-    }
+/**
+ * OddEvenSort class implements the SortAlgorithm interface using the odd-even sort technique.
+ * Odd-even sort is a comparison sort related to bubble sort.
+ * It operates by comparing all (odd, even)-indexed pairs of adjacent elements in the list and, if a pair is in the wrong order, swapping them.
+ * The next step repeats this process for (even, odd)-indexed pairs. This process continues until the list is sorted.
+ *
+ */
+public final class OddEvenSort implements SortAlgorithm {
 
     /**
-     * Odd Even Sort algorithms implements
+     * Sorts the given array using the Odd-Even Sort algorithm.
      *
-     * @param arr the array contains elements
+     * @param <T> the type of elements in the array, which must implement the Comparable interface
+     * @param arr the array to be sorted
+     * @return the sorted array
      */
-    public static void oddEvenSort(int[] arr) {
+    @Override
+    public <T extends Comparable<T>> T[] sort(T[] arr) {
         boolean sorted = false;
         while (!sorted) {
             sorted = true;
 
             for (int i = 1; i < arr.length - 1; i += 2) {
-                if (arr[i] > arr[i + 1]) {
-                    swap(arr, i, i + 1);
+                if (arr[i].compareTo(arr[i + 1]) > 0) {
+                    SortUtils.swap(arr, i, i + 1);
                     sorted = false;
                 }
             }
 
             for (int i = 0; i < arr.length - 1; i += 2) {
-                if (arr[i] > arr[i + 1]) {
-                    swap(arr, i, i + 1);
+                if (arr[i].compareTo(arr[i + 1]) > 0) {
+                    SortUtils.swap(arr, i, i + 1);
                     sorted = false;
                 }
             }
         }
+        return arr;
     }
 
-    /**
-     * Helper function to swap two array values.
-     *
-     * @param arr the array contains elements
-     * @param i the first index to be swapped
-     * @param j the second index to be swapped
-     */
-    private static void swap(int[] arr, int i, int j) {
-        int temp = arr[i];
-        arr[i] = arr[j];
-        arr[j] = temp;
+    public static void main(String[] args) {
+        final Integer[] arr = new Integer[100];
+        final Random random = new Random();
+
+        // Print out unsorted elements
+        for (int i = 0; i < arr.length; ++i) {
+            arr[i] = random.nextInt(100) - 50;
+            System.out.println(arr[i]);
+        }
+        System.out.println("--------------");
+        final OddEvenSort oddEvenSort = new OddEvenSort();
+        oddEvenSort.sort(arr);
+
+        // Print Sorted elements
+        for (int i = 0; i < arr.length - 1; ++i) {
+            System.out.println(arr[i]);
+            assert arr[i] <= arr[i + 1];
+        }
     }
 }

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

@@ -9,28 +9,34 @@
  * @see OddEvenSort
  */
 
-public class OddEvenSortTest {
+public class OddEvenSortTest extends SortingAlgorithmTest {
+    private final OddEvenSort oddEvenSort = new OddEvenSort();
+
+    @Override
+    SortAlgorithm getSortAlgorithm() {
+        return oddEvenSort;
+    }
+
     @Test
     public void oddEvenSortEmptyArray() {
-        int[] inputArray = {};
-        OddEvenSort.oddEvenSort(inputArray);
-        int[] expectedOutput = {};
+        Integer[] inputArray = {};
+        Integer[] expectedOutput = {};
         assertArrayEquals(inputArray, expectedOutput);
     }
 
     @Test
     public void oddEvenSortNaturalNumberArray() {
-        int[] inputArray = {18, 91, 86, 60, 21, 44, 37, 78, 98, 67};
-        OddEvenSort.oddEvenSort(inputArray);
-        int[] expectedOutput = {18, 21, 37, 44, 60, 67, 78, 86, 91, 98};
+        Integer[] inputArray = {18, 91, 86, 60, 21, 44, 37, 78, 98, 67};
+        oddEvenSort.sort(inputArray);
+        Integer[] expectedOutput = {18, 21, 37, 44, 60, 67, 78, 86, 91, 98};
         assertArrayEquals(inputArray, expectedOutput);
     }
 
     @Test
     public void oddEvenSortIntegerArray() {
-        int[] inputArray = {57, 69, -45, 12, -85, 3, -76, 36, 67, -14};
-        OddEvenSort.oddEvenSort(inputArray);
-        int[] expectedOutput = {-85, -76, -45, -14, 3, 12, 36, 57, 67, 69};
+        Integer[] inputArray = {57, 69, -45, 12, -85, 3, -76, 36, 67, -14};
+        oddEvenSort.sort(inputArray);
+        Integer[] expectedOutput = {-85, -76, -45, -14, 3, 12, 36, 57, 67, 69};
         assertArrayEquals(inputArray, expectedOutput);
     }
-}
+}