Repository: TheAlgorithms/Java
File: src/main/java/com/thealgorithms/sorts/BitonicSort.java (Java)

Code before:

    /**
     * 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);
    }

    private <T extends Comparable<T>> void bitonicSort(T[] arr, int low, int cnt, boolean dir) {
        if (cnt > 1) {
            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);
        }
    }

    /**
     * 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) {

Review comment (suggestion):
What do you think about introducing:
```java
private enum Direction {
    DESCENDING,
    ASCENDING,
}
```

Code after:
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 array the array to be sorted
     * @return the sorted array
     */
    @Override
    public <T extends Comparable<T>> T[] sort(T[] array) {
        if (array.length == 0) {
            return array;
        }

        final int paddedSize = nextPowerOfTwo(array.length);
        T[] paddedArray = Arrays.copyOf(array, paddedSize);

        // Fill the padded part with a maximum value
        final T maxValue = max(array);
        Arrays.fill(paddedArray, array.length, paddedSize, maxValue);

        bitonicSort(paddedArray, 0, paddedSize, Direction.ASCENDING);
        return Arrays.copyOf(paddedArray, array.length);
    }

    private <T extends Comparable<T>> void bitonicSort(final T[] array, final int low, final int cnt, final Direction direction) {
        if (cnt > 1) {
            final int k = cnt / 2;

            // Sort first half in ascending order
            bitonicSort(array, low, k, Direction.ASCENDING);

            // Sort second half in descending order
            bitonicSort(array, low + k, cnt - k, Direction.DESCENDING);

            // Merge the whole sequence in ascending order
            bitonicMerge(array, low, cnt, direction);
        }
    }

    /**
     * Merges the bitonic sequence in the specified direction.
     *
     * @param <T> the type of elements in the array, which must be Comparable
     * @param array the array containing the bitonic sequence to be merged
     * @param low the starting index of the sequence to be merged