fix: checkstyle errors

Author: yeoshuheng

src/main/java/algorithms/sorting/radixSort/RadixSort.java

@@ -1,53 +1,69 @@
 package algorithms.sorting.radixSort;
 
 /**
- * Implementation of Radix sort.
- * O((b/r)*(N + 2^r)) 
- * where N is the number of integers, 
- * b is the total number of bits (32 bits for int), 
- * and r is the number of bits for each segment.
- * Space: O(N) auxiliary space.
- */
+* This class implements a Radix Sort Algorithm.
+*/
 public class RadixSort {
-    private static final int NUM_BITS = 8;
-    private static final int NUM_SEGMENTS = 4;
 
-    private static int getSegmentMasked(int num, int segment) {
-        int mask = ((1 << NUM_BITS) - 1) << (segment * NUM_BITS);
-        return (num & mask) >> (segment * NUM_BITS);
-    }
+  private static final int NUM_BITS = 8;
+  private static final int NUM_SEGMENTS = 4;
 
-    private static void radixSort(int[] arr, int[] sorted) {
-        // sort the N numbers by segments, starting from left-most segment
-        for (int i = 0; i < NUM_SEGMENTS; i++) { 
-            int[] freqMap = new int[1 << NUM_BITS]; // at most this number of elements
+  /**
+   * Creates masking on the segment to obtain the value of the digit.
+   *
+   * @param num The number.
+   * @param segment The segment we are interested in.
+   *
+   * @return The value of the digit in the number at the given segment.
+   */
+  private static int getSegmentMasked(int num, int segment) {
+    int mask = ((1 << NUM_BITS) - 1) << (segment * NUM_BITS);
+    return (num & mask) >> (segment * NUM_BITS);
+  }
 
-            // count each element
-            for (int num : arr) {
-                freqMap[getSegmentMasked(num, i)]++;
-            }
-            // get prefix sum
-            for (int j = 1; j < freqMap.length; j++) {
-                freqMap[j] += freqMap[j-1];
-            }
-            // place each number in its correct sorted position up until the given segment
-            for (int k = arr.length-1; k >= 0; k--) {
-                int curr = arr[k];
-                int id = getSegmentMasked(curr, i);
-                sorted[freqMap[id] - 1] = curr;
-                freqMap[id]--;
-            }
-            // we do a swap so that our results above for this segment is saved and passed as input to the next segment
-            int[] tmp = arr;
-            arr = sorted;
-            sorted = tmp;
-        }
-        sorted = arr;
-    }
+  /**
+   * Radix sorts a given input array and updates the output array in-place.
+   *
+   * @param arr original input array.
+   * @param sorted output array.
+   */
+  private static void radixSort(int[] arr, int[] sorted) {
+    // sort the N numbers by segments, starting from left-most segment
+    for (int i = 0; i < NUM_SEGMENTS; i++) {
+      int[] freqMap = new int[1 << NUM_BITS]; // at most this number of elements
 
-    public static void radixSort(int[] arr) {
-        int[] sorted = new int[arr.length];
-        radixSort(arr, sorted);
-        arr = sorted; // swap back lol
+      // count each element
+      for (int num : arr) {
+        freqMap[getSegmentMasked(num, i)]++;
+      }
+      // get prefix sum
+      for (int j = 1; j < freqMap.length; j++) {
+        freqMap[j] += freqMap[j - 1];
+      }
+      // place each number in its correct sorted position up until the given segment
+      for (int k = arr.length - 1; k >= 0; k--) {
+        int curr = arr[k];
+        int id = getSegmentMasked(curr, i);
+        sorted[freqMap[id] - 1] = curr;
+        freqMap[id]--;
+      }
+      // we do a swap so that our results above for this segment is
+      // saved and passed as input to the next segment
+      int[] tmp = arr;
+      arr = sorted;
+      sorted = tmp;
     }
+    sorted = arr;
+  }
+
+  /**
+   * Calls radix sort inplace on a given array.
+   *
+   * @param arr The array to be sorted.
+   */
+  public static void radixSort(int[] arr) {
+    int[] sorted = new int[arr.length];
+    radixSort(arr, sorted);
+    arr = sorted; // swap back lol
+  }
 }

src/test/java/algorithms/sorting/radixSort/RadixSortTest.java

@@ -1,21 +1,21 @@
 package algorithms.sorting.radixSort;
 
 import static org.junit.Assert.assertArrayEquals;
-import org.junit.Test;
+
 import java.util.Arrays;
+import org.junit.Test;
+
 public class RadixSortTest {
   @Test
   public void test_radixSort_shouldReturnSortedArray() {
-    int[] firstArray =
-      new int[] {2, 3, 4, 1, 2, 5, 6, 7, 10, 15, 20, 13, 15, 1, 2,
+    int[] firstArray = new int[] {2, 3, 4, 1, 2, 5, 6, 7, 10, 15, 20, 13, 15, 1, 2,
         15, 12, 20, 21, 120, 11, 5, 7, 85, 30};
     int[] firstResult = Arrays.copyOf(firstArray, firstArray.length);
     RadixSort.radixSort(firstResult);
 
-    int[] secondArray
-      = new int[] {9, 1, 2, 8, 7, 3, 4, 6, 5, 5, 9, 8, 7, 6, 5, 4,
-      3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    int[] secondResult =Arrays.copyOf(secondArray, secondArray.length);
+    int[] secondArray = new int[] {9, 1, 2, 8, 7, 3, 4, 6, 5, 5, 9, 8, 7, 6, 5, 4,
+        3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    int[] secondResult = Arrays.copyOf(secondArray, secondArray.length);
     RadixSort.radixSort(secondResult);
 
     int[] thirdArray = new int[] {};