Add Bucket Sort

Author: imazizbohra

src/Main.java

@@ -7,7 +7,7 @@ public class Main {
     public static void main(String[] args) {
         int[] arr = {5, 3, 4, 2, 1};
 
-        SortingService.sort(arr, SortingAlgorithms.RADIX_SORT);
+        SortingService.sort(arr, SortingAlgorithms.BUCKET_SORT);
 
         System.out.println(Arrays.toString(arr));
     }

src/sort/SortingAlgorithms.java

@@ -6,5 +6,6 @@ public enum SortingAlgorithms {
     INSERTION_SORT,
     CYCLE_SORT,
     COUNTING_SORT,
-    RADIX_SORT
+    RADIX_SORT,
+    BUCKET_SORT
 }

src/sort/SortingService.java

@@ -1,6 +1,7 @@
 package sort;
 
 import sort.bubble.BubbleSort;
+import sort.bucket.BucketSort;
 import sort.counting.CountingSort;
 import sort.cycle.CycleSort;
 import sort.insertion.InsertionSort;
@@ -32,6 +33,9 @@ public static void sort(int[] arr, SortingAlgorithms sortAlgorithms) {
             case RADIX_SORT:
                 RadixSort.sort(arr);
                 break;
+            case BUCKET_SORT:
+                BucketSort.sort(arr);
+                break;
         }
     }
 }

src/sort/bucket/BucketSort.java

@@ -0,0 +1,56 @@
+package sort.bucket;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class BucketSort {
+    public static void sort(int[] arr) {
+        System.out.println("Sorting Elements Using Bucket Sort");
+
+        int n = arr.length;
+
+        // find max element
+        int maxElement = Integer.MIN_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (arr[i] > maxElement)
+                maxElement = arr[i];
+        }
+        // increment to compute right bucket index
+        maxElement++;
+
+        // assume total buckets
+        int totalBuckets = 5;
+
+        // create buckets
+        ArrayList<ArrayList<Integer>> buckets = new ArrayList<>(totalBuckets);
+
+        // add ArrayList to each bucket to hold elements
+        for (int i = 0; i < totalBuckets; i++) {
+            buckets.add(new ArrayList<>());
+        }
+
+        // move elements to their appropriate bucket
+        for (int i = 0; i < n; i++) {
+            int bucketIndex = (totalBuckets * arr[i]) / maxElement;
+            ArrayList<Integer> bucket = buckets.get(bucketIndex);
+            bucket.add(arr[i]);
+        }
+
+        // sort all the buckets individually
+        for (int i = 0; i < totalBuckets; i++) {
+            ArrayList<Integer> bucket = buckets.get(i);
+            Collections.sort(bucket);
+        }
+
+        // concatenate elements of all the buckets
+        int index = 0;
+        for (int i = 0; i < totalBuckets; i++) {
+            ArrayList<Integer> bucket = buckets.get(i);
+
+            for (int j = 0; j < bucket.size(); j++) {
+                arr[index] = bucket.get(j);
+                index++;
+            }
+        }
+    }
+}

src/sort/bucket/README.MD

@@ -0,0 +1,44 @@
+# Bucket Sort
+
+*Sort elements using bucket*
+
+### How It Works: [Link to Video](https://www.youtube.com/watch?v=rNdTWHQMvOk)
+
+### Time Complexity
+
+---
+
+1. **Worst Case Complexity: O(n<sup>2</sup>)**
+   When there are elements of close range in the array, they are likely to be placed in the same bucket. This may result
+   in some buckets having more number of elements than others.
+   It makes the complexity depend on the sorting algorithm used to sort the elements of the bucket.
+   The complexity becomes even worse when the elements are in reverse order. If insertion sort is used to sort elements
+   of the bucket, then the time complexity becomes O(n<sup>2</sup>).
+2. **Best Case Complexity: O(n+k)**
+   It occurs when the elements are uniformly distributed in the buckets with a nearly equal number of elements in each
+   bucket.
+   The complexity becomes even better if the elements inside the buckets are already sorted.
+   If insertion sort is used to sort elements of a bucket then the overall complexity in the best case will be linear
+   ie. O(n+k). O(n) is the complexity for making the buckets and O(k) is the complexity for sorting the elements of the
+   bucket using algorithms having linear time complexity at the best case.
+3. **Average Case Complexity: O(n)**
+   It occurs when the elements are distributed randomly in the array. Even if the elements are not distributed
+   uniformly, bucket sort runs in linear time. It holds true until the sum of the squares of the bucket sizes is linear
+   in the total number of elements.
+
+### Space Complexity
+
+---
+
+1. The space complexity of Bucket Sort is O(n+k) where k is no of buckets
+
+### Properties
+
+1. May or may not be Stable
+2. Not Inplace
+3. Buckets are used to sort elements
+
+### Applications
+
+1. Input is uniformly distributed over a range.
+2. There are floating point values

src/sort/radix/RadixSort.java

@@ -2,6 +2,8 @@
 
 public class RadixSort {
     public static void sort(int[] arr) {
+        System.out.println("Sorting Elements Using Radix Sort");
+
         int n = arr.length;
 
         // find max element in the array