Improving BitonicSort

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

@@ -1,79 +1,94 @@
 package com.thealgorithms.sorts;
 
-/* Java program for Bitonic Sort. Note that this program
-works only when size of input is a power of 2. */
-public class BitonicSort {
-
-    /* The parameter dir indicates the sorting direction,
-  ASCENDING or DESCENDING; if (a[i] > a[j]) agrees
-  with the direction, then a[i] and a[j] are
-  interchanged. */
-    void compAndSwap(int[] a, int i, int j, int dir) {
-        if ((a[i] > a[j] && dir == 1) || (a[i] < a[j] && dir == 0)) {
-            // Swapping elements
-            int temp = a[i];
-            a[i] = a[j];
-            a[j] = temp;
+import java.util.Arrays;
+
+/**
+ * BitonicSort class implements the SortAlgorithm interface using the bitonic sort technique.
+ */
+public class BitonicSort implements SortAlgorithm {
+
+    /**
+     * 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
+     * @return the sorted array
+     */
+    @Override
+    public <T extends Comparable<T>> T[] sort(T[] arr) {
+        if (arr == null || arr.length == 0) {
+            return arr;
         }
+
+        final int paddedSize = nextPowerOfTwo(arr.length);
+        T[] paddedArray = Arrays.copyOf(arr, paddedSize);
+
+        // Fill the padded part with a maximum value
+        final T maxValue = SortUtils.max(arr);
+        Arrays.fill(paddedArray, arr.length, paddedSize, maxValue);
+
+        bitonicSort(paddedArray, 0, paddedSize, true);
+        return Arrays.copyOf(paddedArray, arr.length);
     }
 
-    /* It recursively sorts a bitonic sequence in ascending
-  order, if dir = 1, and in descending order otherwise
-  (means dir=0). The sequence to be sorted starts at
-  index position low, the parameter cnt is the number
-  of elements to be sorted.*/
-    void bitonicMerge(int[] a, int low, int cnt, int dir) {
+    private <T extends Comparable<T>> void bitonicSort(T[] arr, int low, int cnt, boolean dir) {
         if (cnt > 1) {
-            int k = cnt / 2;
-            for (int i = low; i < low + k; i++) {
-                compAndSwap(a, i, i + k, dir);
-            }
-            bitonicMerge(a, low, k, dir);
-            bitonicMerge(a, low + k, k, dir);
+            final int k = cnt / 2;
+
+            // Sort first half in ascending order
+            bitonicSort(arr, low, k, true);
+
+            // Sort second half in descending order
+            bitonicSort(arr, low + k, cnt - k, false);
+
+            // Merge the whole sequence in ascending order
+            bitonicMerge(arr, low, cnt, dir);
         }
     }
 
-    /* This funcion first produces a bitonic sequence by
-  recursively sorting its two halves in opposite sorting
-  orders, and then calls bitonicMerge to make them in
-  the same order */
-    void bitonicSort(int[] a, int low, int cnt, int dir) {
+    /**
+     * Merges the bitonic sequence in the specified direction.
+     *
+     * @param <T> the type of elements in the array, which must be Comparable
+     * @param arr the array containing the bitonic sequence to be merged
+     * @param low the starting index of the sequence to be merged
+     * @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) {
         if (cnt > 1) {
-            int k = cnt / 2;
-
-            // sort in ascending order since dir here is 1
-            bitonicSort(a, low, k, 1);
+            final int k = cnt / 2;
 
-            // sort in descending order since dir here is 0
-            bitonicSort(a, low + k, k, 0);
+            for (int i = low; i < low + k; i++) {
+                if (dir == (arr[i].compareTo(arr[i + k]) > 0)) {
+                    SortUtils.swap(arr, i, i + k);
+                }
+            }
 
-            // Will merge whole sequence in ascending order
-            // since dir=1.
-            bitonicMerge(a, low, cnt, dir);
+            bitonicMerge(arr, low, k, dir);
+            bitonicMerge(arr, low + k, cnt - k, dir);
         }
     }
 
-    /*Caller of bitonicSort for sorting the entire array
-  of length N in ASCENDING order */
-    void sort(int[] a, int n, int up) {
-        bitonicSort(a, 0, n, up);
-    }
+    /**
+     * Finds the next power of two greater than or equal to the given number.
+     *
+     * @param n the number
+     * @return the next power of two
+     */
+    private static int nextPowerOfTwo(int n) {
+        int count = 0;
 
-    /* A utility function to print array of size n */
-    static void printArray(int[] arr) {
-        int n = arr.length;
-        for (int i = 0; i < n; ++i) {
-            System.out.print(arr[i] + " ");
+        // First n in the below condition is for the case where n is 0
+        if ((n & (n - 1)) == 0) {
+            return n;
+        }
+
+        while (n != 0) {
+            n >>= 1;
+            count += 1;
         }
-        System.out.println();
-    }
 
-    public static void main(String[] args) {
-        int[] a = {3, 7, 4, 8, 6, 2, 1, 5};
-        int up = 1;
-        BitonicSort ob = new BitonicSort();
-        ob.sort(a, a.length, up);
-        System.out.println("\nSorted array");
-        printArray(a);
+        return 1 << count;
     }
 }

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

@@ -116,4 +116,26 @@ 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

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