[BAEL-3193] - changes made to clean up code (#7760)

* [BAEL-3193] - changes made to clean up code

* Fixed missing linkedList import

* [BAEL-3193] - changing the default value in the findMax function

algorithms-sorting/src/main/java/com/baeldung/algorithms/bucketsort/IntegerBucketSorter.java

@@ -0,0 +1,68 @@
+package com.baeldung.bucketsort;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IntegerBucketSorter implements Sorter<Integer> {
+
+    private final Comparator<Integer> comparator;
+
+    public IntegerBucketSorter(Comparator<Integer> comparator) {
+        this.comparator = comparator;
+    }
+
+    public IntegerBucketSorter() {
+        comparator = Comparator.naturalOrder();
+    }
+
+    public List<Integer> sort(List<Integer> arrayToSort) {
+
+        List<List<Integer>> buckets = splitIntoUnsortedBuckets(arrayToSort);
+
+        for(List<Integer> bucket  : buckets){
+            bucket.sort(comparator);
+        }
+
+        return concatenateSortedBuckets(buckets);
+    }
+
+    private List<Integer> concatenateSortedBuckets(List<List<Integer>> buckets){
+        List<Integer> sortedArray = new LinkedList<>();
+        for(List<Integer> bucket : buckets){
+            sortedArray.addAll(bucket);
+        }
+        return sortedArray;
+    }
+
+    private List<List<Integer>> splitIntoUnsortedBuckets(List<Integer> initialList){
+
+        final int max = findMax(initialList);
+        final int numberOfBuckets = (int) Math.sqrt(initialList.size());
+
+        List<List<Integer>> buckets = new ArrayList<>();
+        for(int i = 0; i < numberOfBuckets; i++) buckets.add(new ArrayList<>());
+
+        //distribute the data
+        for (int i : initialList) {
+            buckets.get(hash(i, max, numberOfBuckets)).add(i);
+        }
+        return buckets;
+
+    }
+
+    private int findMax(List<Integer> input){
+        int m = Integer.MIN_VALUE;
+        for (int i : input){
+            m = Math.max(i, m);
+        }
+        return m;
+    }
+
+    private static int hash(int i, int max, int numberOfBuckets) {
+        return (int) ((double) i / max * (numberOfBuckets - 1));
+    }
+
+
+}

algorithms-sorting/src/main/java/com/baeldung/algorithms/bucketsort/Sorter.java

@@ -0,0 +1,8 @@
+package com.baeldung.bucketsort;
+
+import java.util.List;
+
+public interface Sorter<T> {
+
+    List<T> sort(List<T> arrayToSort);
+}

algorithms-sorting/src/test/java/com/baeldung/algorithms/bucketsort/IntegerBucketSorterUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.bucketsort;
+
+import com.baeldung.bucketsort.IntegerBucketSorter;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class IntegerBucketSorterUnitTest {
+
+    private IntegerBucketSorter sorter;
+
+    @Before
+    public void setUp() throws Exception {
+        sorter = new IntegerBucketSorter();
+    }
+
+    @Test
+    public void givenUnsortedList_whenSortedUsingBucketSorter_checkSortingCorrect() {
+
+        List<Integer> unsorted = Arrays.asList(80,50,60,30,20,10,70,0,40,500,600,602,200,15);
+        List<Integer> expected = Arrays.asList(0,10,15,20,30,40,50,60,70,80,200,500,600,602);
+
+        List<Integer> actual = sorter.sort(unsorted);
+
+        assertEquals(expected, actual);
+
+
+    }
+}