refactor: cleanup RadixSort

DIRECTORY.md

@@ -875,9 +875,11 @@
             * [IntrospectiveSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/IntrospectiveSortTest.java)
             * [MergeSortRecursiveTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/MergeSortRecursiveTest.java)
             * [MergeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/MergeSortTest.java)
+            * [MergeSortNoExtraSpaceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/MergeSortNoExtraSpaceTest.java)
             * [OddEvenSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/OddEvenSortTest.java)
             * [PancakeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/PancakeSortTest.java)
             * [QuickSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/QuickSortTest.java)
+            * [RadixSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/RadixSortTest.java)
             * [SelectionSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SelectionSortTest.java)
             * [SelectionSortRecursiveTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SelectionSortRecursiveTest.java)
             * [ShellSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/ShellSortTest.java)

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

@@ -2,61 +2,58 @@
 
 import java.util.Arrays;
 
-final class RadixSort {
+/**
+ * This class provides an implementation of the radix sort algorithm.
+ * It sorts an array of integers in increasing order.
+ */
+public final class RadixSort {
     private RadixSort() {
     }
 
-    private static int getMax(int[] arr, int n) {
-        int mx = arr[0];
-        for (int i = 1; i < n; i++) {
-            if (arr[i] > mx) {
-                mx = arr[i];
-            }
+    /**
+     * Sorts an array of integers using the radix sort algorithm.
+     *
+     * @param array the array to be sorted
+     * @return the sorted array
+     */
+    public static int[] sort(int[] array) {
+        if (array.length == 0) {
+            return array;
         }
-        return mx;
+
+        final int max = Arrays.stream(array).max().getAsInt();
+        for (int exp = 1; max / exp > 0; exp *= 10) {
+            countingSortByDigit(array, exp);
+        }
+
+        return array;
     }
 
-    private static void countSort(int[] arr, int n, int exp) {
-        int[] output = new int[n];
-        int i;
+    /**
+     * A utility method to perform counting sort of array[] according to the digit represented by exp.
+     *
+     * @param array the array to be sorted
+     * @param exp   the exponent representing the current digit position
+     */
+    private static void countingSortByDigit(int[] array, int exp) {
+        int[] output = new int[array.length];
         int[] count = new int[10];
-        Arrays.fill(count, 0);
 
-        for (i = 0; i < n; i++) {
-            count[(arr[i] / exp) % 10]++;
+        for (int i = 0; i < array.length; i++) {
+            count[(array[i] / exp) % 10]++;
         }
 
-        for (i = 1; i < 10; i++) {
+        for (int i = 1; i < 10; i++) {
             count[i] += count[i - 1];
         }
 
-        for (i = n - 1; i >= 0; i--) {
-            output[count[(arr[i] / exp) % 10] - 1] = arr[i];
-            count[(arr[i] / exp) % 10]--;
-        }
-
-        System.arraycopy(output, 0, arr, 0, n);
-    }
-
-    private static void radixsort(int[] arr, int n) {
-        int m = getMax(arr, n);
-
-        for (int exp = 1; m / exp > 0; exp *= 10) {
-            countSort(arr, n, exp);
-        }
-    }
-
-    static void print(int[] arr, int n) {
-        for (int i = 0; i < n; i++) {
-            System.out.print(arr[i] + " ");
+        for (int i = array.length - 1; i >= 0; i--) {
+            int digit = (array[i] / exp) % 10;
+            output[count[digit] - 1] = array[i];
+            count[digit]--;
         }
-    }
 
-    public static void main(String[] args) {
-        int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
-        int n = arr.length;
-        radixsort(arr, n);
-        print(arr, n);
+        System.arraycopy(output, 0, array, 0, array.length);
     }
 }
 // Written by James Mc Dermott(theycallmemac)

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

@@ -0,0 +1,23 @@
+package com.thealgorithms.sorts;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class RadixSortTest {
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    public void test(int[] inputArray, int[] expectedArray) {
+        assertArrayEquals(RadixSort.sort(inputArray), expectedArray);
+    }
+
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(Arguments.of(new int[] {170, 45, 75, 90, 802, 24, 2, 66}, new int[] {2, 24, 45, 66, 75, 90, 170, 802}), Arguments.of(new int[] {3, 3, 3, 3}, new int[] {3, 3, 3, 3}), Arguments.of(new int[] {9, 4, 6, 8, 14, 3}, new int[] {3, 4, 6, 8, 9, 14}),
+            Arguments.of(new int[] {10, 90, 49, 2, 1, 5, 23}, new int[] {1, 2, 5, 10, 23, 49, 90}), Arguments.of(new int[] {1, 3, 4, 2, 7, 8}, new int[] {1, 2, 3, 4, 7, 8}), Arguments.of(new int[] {}, new int[] {}), Arguments.of(new int[] {1}, new int[] {1}),
+            Arguments.of(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}, new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}), Arguments.of(new int[] {9, 8, 7, 6, 5, 4, 3, 2, 1}, new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}),
+            Arguments.of(new int[] {1000000000, 999999999, 888888888, 777777777}, new int[] {777777777, 888888888, 999999999, 1000000000}));
+    }
+}