Fix for test and code improvements

Author: AlexKlm

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

@@ -6,40 +6,44 @@
  * BitonicSort class implements the SortAlgorithm interface using the bitonic sort technique.
  */
 public class BitonicSort implements SortAlgorithm {
+    private enum Direction {
+        DESCENDING,
+        ASCENDING,
+    }
 
     /**
      * Sorts the given array using the Bitonic Sort algorithm.
      *
      * @param <T> the type of elements in the array, which must implement the Comparable interface
-     * @param arr the array to be sorted
+     * @param unsorted the array to be sorted
      * @return the sorted array
      */
     @Override
-    public <T extends Comparable<T>> T[] sort(T[] arr) {
-        if (arr == null || arr.length == 0) {
-            return arr;
+    public <T extends Comparable<T>> T[] sort(T[] unsorted) {
+        if (unsorted == null || unsorted.length == 0) {
+            return unsorted;
         }
 
-        final int paddedSize = nextPowerOfTwo(arr.length);
-        T[] paddedArray = Arrays.copyOf(arr, paddedSize);
+        final int paddedSize = nextPowerOfTwo(unsorted.length);
+        T[] paddedArray = Arrays.copyOf(unsorted, paddedSize);
 
         // Fill the padded part with a maximum value
-        final T maxValue = SortUtils.max(arr);
-        Arrays.fill(paddedArray, arr.length, paddedSize, maxValue);
+        final T maxValue = max(unsorted);
+        Arrays.fill(paddedArray, unsorted.length, paddedSize, maxValue);
 
-        bitonicSort(paddedArray, 0, paddedSize, true);
-        return Arrays.copyOf(paddedArray, arr.length);
+        bitonicSort(paddedArray, 0, paddedSize, Direction.ASCENDING);
+        return Arrays.copyOf(paddedArray, unsorted.length);
     }
 
-    private <T extends Comparable<T>> void bitonicSort(T[] arr, int low, int cnt, boolean dir) {
+    private <T extends Comparable<T>> void bitonicSort(T[] arr, int low, int cnt, Direction dir) {
         if (cnt > 1) {
             final int k = cnt / 2;
 
             // Sort first half in ascending order
-            bitonicSort(arr, low, k, true);
+            bitonicSort(arr, low, k, Direction.ASCENDING);
 
             // Sort second half in descending order
-            bitonicSort(arr, low + k, cnt - k, false);
+            bitonicSort(arr, low + k, cnt - k, Direction.DESCENDING);
 
             // Merge the whole sequence in ascending order
             bitonicMerge(arr, low, cnt, dir);
@@ -55,12 +59,13 @@ private <T extends Comparable<T>> void bitonicSort(T[] arr, int low, int cnt, bo
      * @param cnt the number of elements in the sequence to be merged
      * @param dir the direction of sorting: true for ascending, false for descending
      */
-    private <T extends Comparable<T>> void bitonicMerge(T[] arr, int low, int cnt, boolean dir) {
+    private <T extends Comparable<T>> void bitonicMerge(T[] arr, int low, int cnt, Direction dir) {
         if (cnt > 1) {
             final int k = cnt / 2;
 
             for (int i = low; i < low + k; i++) {
-                if (dir == (arr[i].compareTo(arr[i + k]) > 0)) {
+                boolean condition = (dir == Direction.ASCENDING) ? arr[i].compareTo(arr[i + k]) > 0 : arr[i].compareTo(arr[i + k]) < 0;
+                if (condition) {
                     SortUtils.swap(arr, i, i + k);
                 }
             }
@@ -91,4 +96,22 @@ private static int nextPowerOfTwo(int n) {
 
         return 1 << count;
     }
+
+    /**
+     * Finds the maximum element in the given array.
+     *
+     * @param <T> the type of elements in the array, which must implement the Comparable interface
+     * @param array the array to be searched
+     * @return the maximum element in the array
+     * @throws IllegalArgumentException if the array is null or empty
+     */
+    private static <T extends Comparable<T>> T max(T[] array) {
+        T max = array[0];
+        for (T element : array) {
+            if (SortUtils.greater(element, max)) {
+                max = element;
+            }
+        }
+        return max;
+    }
 }

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

@@ -116,26 +116,4 @@ public static <T extends Comparable<T>> boolean isSorted(List<T> list) {
         }
         return true;
     }
-
-    /**
-     * Finds the maximum element in the given array.
-     *
-     * @param <T> the type of elements in the array, which must implement the Comparable interface
-     * @param array the array to be searched
-     * @return the maximum element in the array
-     * @throws IllegalArgumentException if the array is null or empty
-     */
-    public static <T extends Comparable<T>> T max(T[] array) {
-        if (array == null || array.length == 0) {
-            throw new IllegalArgumentException("Array must not be null or empty");
-        }
-
-        T max = array[0];
-        for (T element : array) {
-            if (element.compareTo(max) > 0) {
-                max = element;
-            }
-        }
-        return max;
-    }
 }

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

@@ -1,10 +1,8 @@
 package com.thealgorithms.sorts;
 
 public class BitonicSortTest extends SortingAlgorithmTest {
-    private final BitonicSort bitonicSort = new BitonicSort();
-
     @Override
     SortAlgorithm getSortAlgorithm() {
-        return bitonicSort;
+        return new BitonicSort();
     }
 }