Fix/clean up all java sorting algorithms

Author: jwl-7

src/code/java/sorting_algorithms/bogo_sort.java

@@ -2,7 +2,7 @@
 import java.util.Random;
 
 
-public void bogoSort(int[] arr) {
+public static void bogoSort(int[] arr) {
     int[] target = Arrays.copyOf(arr, arr.length);
     Arrays.sort(target);
 
@@ -11,8 +11,9 @@ public void bogoSort(int[] arr) {
     }
 }
 
-public void shuffleArray(int[] arr) {
+public static void shuffleArray(int[] arr) {
     Random rnd = new Random();
+
     for (int i = arr.length - 1; i > 0; i--) {
         int index = rnd.nextInt(i + 1);
         int temp = arr[index];

src/code/java/sorting_algorithms/bubble_sort.java

@@ -1,4 +1,4 @@
-public void bubbleSort(int[] arr) {
+public static void bubbleSort(int[] arr) {
     int n = arr.length;
 
     for (int i = 0; i < n; i++) {

src/code/java/sorting_algorithms/bucket_sort.java

@@ -1,12 +1,15 @@
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
 
-public List<Integer> bucketSort(List<Integer> arr) {
+public static int[] bucketSort(int[] arr) {
     int numBuckets = 10;
-    int minNum = Collections.min(arr);
-    int maxNum = Collections.max(arr);
+    int index;
+    int[] result = new int[arr.length];
+    int minNum = Arrays.stream(arr).min().getAsInt();
+    int maxNum = Arrays.stream(arr).max().getAsInt();
     double bucketSize = (double) (maxNum - minNum) / numBuckets;
     List<List<Integer>> buckets = new ArrayList<>(numBuckets);
 
@@ -15,14 +18,18 @@ public List<Integer> bucketSort(List<Integer> arr) {
     }
 
     for (int num : arr) {
-        int index = Math.min((int) ((num - minNum) / bucketSize), numBuckets - 1);
+        index = Math.min((int) ((num - minNum) / bucketSize), numBuckets - 1);
         buckets.get(index).add(num);
     }
 
-    List<Integer> result = new ArrayList<>();
+    index = 0;
+
     for (List<Integer> bucket : buckets) {
         Collections.sort(bucket);
-        result.addAll(bucket);
+
+        for (int num : bucket) {
+            result[index++] = num;
+        }
     }
 
     return result;

src/code/java/sorting_algorithms/counting_sort.java

@@ -1,7 +1,7 @@
 import java.util.Arrays;
 
 
-public int[] countingSort(int[] arr) {
+public static int[] countingSort(int[] arr) {
     int maxNum = Arrays.stream(arr).max().orElse(Integer.MIN_VALUE);
     int minNum = Arrays.stream(arr).min().orElse(Integer.MAX_VALUE);
     int countRange = maxNum - minNum + 1;

src/code/java/sorting_algorithms/cube_sort.java

@@ -3,37 +3,40 @@
 import java.util.List;
 
 
-public void cubeSort(int[] arr, int processors) {
+public static void cubeSort(int[] arr, int processors) {
     int n = arr.length;
     List<int[]> subarrays = new ArrayList<>();
-    int subarraySize = n / processors;
+    int subarraySize = (n + processors - 1) / processors;
 
     for (int i = 0; i < processors; i++) {
-        int[] subarray = Arrays.copyOfRange(arr, i * subarraySize, (i + 1) * subarraySize);
+        int[] subarray = new int[Math.min(subarraySize, n - i * subarraySize)];
+        System.arraycopy(arr, i * subarraySize, subarray, 0, subarray.length);
         Arrays.sort(subarray);
         subarrays.add(subarray);
     }
 
     for (int dimension = 0; dimension < Integer.SIZE - 1; dimension++) {
         for (int i = 0; i < processors; i++) {
             int partner = i ^ (1 << dimension);
-            if (i < partner) {
+
+            if (i < partner && partner < processors) {
                 int[] merged = merge(subarrays.get(i), subarrays.get(partner));
-                subarrays.set(i, Arrays.copyOfRange(merged, 0, subarraySize));
-                subarrays.set(partner, Arrays.copyOfRange(merged, subarraySize, merged.length));
+                System.arraycopy(merged, 0, subarrays.get(i), 0, subarraySize);
+                System.arraycopy(merged, subarraySize, subarrays.get(partner), 0, subarraySize);
             }
         }
     }
 
     int index = 0;
+
     for (int[] subarray : subarrays) {
         for (int num : subarray) {
             arr[index++] = num;
         }
     }
 }
 
-public int[] merge(int[] arr1, int[] arr2) {
+public static int[] merge(int[] arr1, int[] arr2) {
     int[] merged = new int[arr1.length + arr2.length];
     int i = 0, j = 0, k = 0;
 

src/code/java/sorting_algorithms/heap_sort.java

@@ -1,4 +1,4 @@
-public int[] heapSort(int[] arr) {
+public static int[] heapSort(int[] arr) {
     int n = arr.length;
 
     for (int i = n / 2 - 1; i >= 0; i--) {
@@ -16,7 +16,7 @@ public int[] heapSort(int[] arr) {
     return arr;
 }
 
-public void heapify(int[] arr, int n, int i) {
+public static void heapify(int[] arr, int n, int i) {
     int largest = i;
     int left = 2 * i + 1;
     int right = 2 * i + 2;

src/code/java/sorting_algorithms/insertion_sort.java

@@ -1,4 +1,4 @@
-public void insertionSort(int[] arr) {
+public static void insertionSort(int[] arr) {
     int n = arr.length;
 
     for (int i = 1; i < n; i++) {

src/code/java/sorting_algorithms/merge_sort.java

@@ -1,7 +1,7 @@
 import java.util.Arrays;
 
 
-public int[] mergeSort(int[] arr) {
+public static int[] mergeSort(int[] arr) {
     int n = arr.length;
 
     if (n <= 1) {
@@ -18,7 +18,7 @@ public int[] mergeSort(int[] arr) {
     return merge(left, right);
 }
 
-public int[] merge(int[] left, int[] right) {
+public static int[] merge(int[] left, int[] right) {
     int[] output = new int[left.length + right.length];
     int i = 0, j = 0, k = 0;
 

src/code/java/sorting_algorithms/pancake_sort.java

@@ -1,4 +1,4 @@
-public void pancakeSort(int[] arr) {
+public static void pancakeSort(int[] arr) {
     int n = arr.length;
 
     for (int size = n; size >= 2; size--) {
@@ -11,7 +11,7 @@ public void pancakeSort(int[] arr) {
     }
 }
 
-public void flip(int[] arr, int i) {
+public static void flip(int[] arr, int i) {
     int left = 0;
 
     while (left < i) {
@@ -23,7 +23,7 @@ public void flip(int[] arr, int i) {
     }
 }
 
-public int findMaxIndex(int[] arr, int n) {
+public static int findMaxIndex(int[] arr, int n) {
     int maxIdx = 0;
 
     for (int i = 0; i < n; i++) {

src/code/java/sorting_algorithms/quick_sort.java

@@ -2,7 +2,7 @@
 import java.util.List;
 
 
-public int[] quickSort(int[] arr) {
+public static int[] quickSort(int[] arr) {
     int n = arr.length;
 
     if (n <= 1) {
@@ -23,8 +23,8 @@ public int[] quickSort(int[] arr) {
 
     int[] sortedLeft = quickSort(left.stream().mapToInt(i -> i).toArray());
     int[] sortedRight = quickSort(right.stream().mapToInt(i -> i).toArray());
-
     int[] result = new int[n];
+
     System.arraycopy(sortedLeft, 0, result, 0, sortedLeft.length);
     result[sortedLeft.length] = pivot;
     System.arraycopy(sortedRight, 0, result, sortedLeft.length + 1, sortedRight.length);