refactor: remove negative integers support

Author: alxklm

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

@@ -1,11 +1,12 @@
 package com.thealgorithms.sorts;
 
 import com.thealgorithms.maths.NumberOfDigits;
+
 import java.util.Arrays;
 
 /**
  * This class provides an implementation of the radix sort algorithm.
- * It sorts an array of integers in increasing order.
+ * It sorts an array of positive integers in increasing order.
  */
 public final class RadixSort {
     private static final int BASE = 10;
@@ -14,37 +15,34 @@ private RadixSort() {
     }
 
     /**
-     * Sorts an array of integers using the radix sort algorithm.
+     * Sorts an array of positive integers using the radix sort algorithm.
      *
      * @param array the array to be sorted
      * @return the sorted array
+     * @throws IllegalArgumentException if any negative integers are found
      */
     public static int[] sort(int[] array) {
         if (array.length == 0) {
             return array;
         }
 
-        int[] negatives = Arrays.stream(array).filter(x -> x < 0).map(x -> - x).toArray();
-        int[] positives = Arrays.stream(array).filter(x -> x >= 0).toArray();
-
-        if (negatives.length > 0) {
-            radixSort(negatives);
-            reverseAndNegate(negatives);
-        }
-
-        if (positives.length > 0) {
-            radixSort(positives);
-        }
-
-        int[] sortedArray = new int[array.length];
-        mergeNegativeAndPositiveArrays(negatives, sortedArray, positives);
-
-        return sortedArray;
+        checkForNegativeInput(array);
+        radixSort(array);
+        return array;
     }
 
-    private static void mergeNegativeAndPositiveArrays(int[] negatives, int[] sortedArray, int[] positives) {
-        System.arraycopy(negatives, 0, sortedArray, 0, negatives.length);
-        System.arraycopy(positives, 0, sortedArray, negatives.length, positives.length);
+    /**
+     * Checks if the array contains any negative integers.
+     *
+     * @param array the array to be checked
+     * @throws IllegalArgumentException if any negative integers are found
+     */
+    private static void checkForNegativeInput(int[] array) {
+        for (int number : array) {
+            if (number < 0) {
+                throw new IllegalArgumentException("Array contains non-positive integers.");
+            }
+        }
     }
 
     private static void radixSort(int[] array) {
@@ -54,17 +52,6 @@ private static void radixSort(int[] array) {
         }
     }
 
-    private static void reverseAndNegate(int[] array) {
-        for (int i = 0; i < array.length / 2; i++) {
-            int temp = array[i];
-            array[i] = -array[array.length - 1 - i];
-            array[array.length - 1 - i] = -temp;
-        }
-        if (array.length % 2 != 0) {
-            array[array.length / 2] = -array[array.length / 2];
-        }
-    }
-
     /**
      * A utility method to perform counting sort of array[] according to the digit represented by exp.
      *

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

@@ -1,8 +1,11 @@
 package com.thealgorithms.sorts;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -18,9 +21,11 @@ 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}), Arguments.of(new int[] {123, 9, 54321, 123456789, 0}, new int[] {0, 9, 123, 54321, 123456789}),
-            Arguments.of(new int[] {-170, 45, -75, 90, -802, 24, -2, 66}, new int[] {-802, -170, -75, -2, 24, 45, 66, 90}), 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[] {-14, -9, -8, -6, -4, -3}),
-            Arguments.of(new int[] {10, -90, 49, -2, 1, -5, 23}, new int[] {-90, -5, -2, 1, 10, 23, 49}), Arguments.of(new int[] {-1, -3, -4, -2, -7, -8}, new int[] {-8, -7, -4, -3, -2, -1}), Arguments.of(new int[] {1, -1, 0, -100, 100}, new int[] {-100, -1, 0, 1, 100}),
-            Arguments.of(new int[] {-1000000000, 999999999, -888888888, 777777777}, new int[] {-1000000000, -888888888, 777777777, 999999999}), Arguments.of(new int[] {-123, 9, -54321, 123456789, 0}, new int[] {-54321, -123, 0, 9, 123456789}));
+            Arguments.of(new int[] {1000000000, 999999999, 888888888, 777777777}, new int[] {777777777, 888888888, 999999999, 1000000000}), Arguments.of(new int[] {123, 9, 54321, 123456789, 0}, new int[] {0, 9, 123, 54321, 123456789}));
+    }
+
+    @Test
+    public void testWithNegativeNumbers() {
+        assertThrows(IllegalArgumentException.class, () -> RadixSort.sort(new int[] {3, 1, 4, 1, 5, -9}));
     }
 }