Bucket Sort

Author: carlos-paezf

DOC/Bucket_Sort.md

@@ -0,0 +1,82 @@
+# Bucket Sort
+
+Bucket Sort is a comparison sort algorithm that operates on elements by dividing them into different buckets and then sorting these buckets individually. Each bucket is sorted individually using a separate sorting algorithm or by applying the bucket sort algorithm recursively. Bucket sort is mainly useful when the input es uniformly distributed over a range.
+
+Assume one has the following problem in front of them:
+
+One has been given a large array of floating-point integers lying uniformly between the lower and upper bound. This array now needs to be sorted. A simple way to solve this problem would be to use another sorting algorithm such as Merge sort, Heap sort, or Quicksort. However, these algorithms guarantee a best case time complexity of *O(N log N)* However, using bucket sort, the above task can be completed in *O(N)* time. Let's have a closes look at it.
+
+Consider one needs to create an array of lists, i.e of buckets. Elements now need to be inserted into these buckets on the basis of their properties. Each of these buckets can then be sorted individually using Insertion Sort.
+
+## Implementation
+
+Bucket sort for numbers having interger part
+
+```python
+def bucket_sort(data, n_buckets, draw_data, time_tick):
+    max_element = max(data)
+    min_element = min(data)
+```
+
+Range for buckets
+
+```python
+    ran = (max_element - min_element) / n_buckets
+    temp = []
+```
+
+Create empty buckets.
+
+```python
+    for i in range(n_buckets):
+        temp.append([])
+```
+
+Scatter the array elements into the correct bucket.
+
+```python
+    for i in range(len(data)):
+        diff = (data[i] - min_element) / ran - int((data[i] - min_element) / ran)
+```
+
+Append the boundary elements to the lower array.
+
+```python
+        if diff == 0 and data[i] != min_element:
+            temp[int((data[i] - min_element) / ran) - 1].append(data[i])
+        else:
+            temp[int((data[i] - min_element) / ran)].append(data[i])
+```
+
+Sort each bucket individually.
+
+```python
+    for i in range(len(temp)):
+        if len(temp[i]) != 0:
+            temp[i].sort()
+```
+
+Gather sorted elements to the original array.
+
+```python
+    k = 0
+    for lst in temp:
+        if lst:
+            for i in lst:
+                data[k] = i
+                k += 1
+```
+
+Draw the data being compared and the finalized.
+
+```python
+                draw_data(data, [LIGHT_GREEN for x in range(len(temp))])
+                time.sleep(time_tick)
+    return draw_data(data, [BLUE for x in range(len(data))])
+```
+
+## Example
+
+<p align="center">
+    <img src="../images/bucket_sort.png" />
+</p>

README.md

@@ -75,7 +75,8 @@ algorithm_list = [
     'Quick Sort', 
     'Counting Sort',
     'Radix Sort',
-    'Heap Sort'
+    'Heap Sort',
+    'Bucket Sort'
 ]
 ```
 
@@ -245,6 +246,7 @@ from algorithms.quickSort import quick_sort
 from algorithms.countingSort import counting_sort
 from algorithms.radixSort import radix_sort
 from algorithms.heapSort import heap_sort
+from algorithms.bucketSort import bucket_sort
 ```
 
 ```python
@@ -267,6 +269,8 @@ def sort():
         radix_sort(data, draw_data, time_tick)
     elif algorithm_menu.get() == 'Heap Sort':
         heap_sort(data, draw_data, time_tick)
+    elif algorithm_menu.get() == 'Bucket Sort':
+        bucket_sort(data, len(data), draw_data, time_tick)
     else: 
         pass
 ```
@@ -293,4 +297,8 @@ GeeksforGeeks. (2021, 15 junio). Radix Sort. https://www.geeksforgeeks.org/radix
 
 Heap Sort Tutorials & Notes | Algorithms. (2016, 24 abril). HackerEarth. https://www.hackerearth.com/practice/algorithms/sorting/heap-sort/tutorial/
 
-GeeksforGeeks. (2020, 30 diciembre). Python Program for Heap Sort. https://www.geeksforgeeks.org/python-program-for-heap-sort/
+GeeksforGeeks. (2020, 30 diciembre). Python Program for Heap Sort. https://www.geeksforgeeks.org/python-program-for-heap-sort/
+
+Bucket Sort Tutorials & Notes | Algorithms. (2016, 24 abril). HackerEarth. https://www.hackerearth.com/practice/algorithms/sorting/bucket-sort/tutorial/
+
+GeeksforGeeks. (2021, 8 junio). Bucket Sort. https://www.geeksforgeeks.org/bucket-sort-2/

algorithms/__pycache__/bucketSort.cpython-39.pyc

@@ -0,0 +1,29 @@
+import time
+from colors import *
+
+
+def bucket_sort(data, n_buckets, draw_data, time_tick):
+    max_element = max(data)
+    min_element = min(data)
+    ran = (max_element - min_element) / n_buckets
+    temp = []
+    for i in range(n_buckets):
+        temp.append([])
+    for i in range(len(data)):
+        diff = (data[i] - min_element) / ran - int((data[i] - min_element) / ran)
+        if diff == 0 and data[i] != min_element:
+            temp[int((data[i] - min_element) / ran) - 1].append(data[i])
+        else:
+            temp[int((data[i] - min_element) / ran)].append(data[i])
+    for i in range(len(temp)):
+        if len(temp[i]) != 0:
+            temp[i].sort()
+    k = 0
+    for lst in temp:
+        if lst:
+            for i in lst:
+                data[k] = i
+                k += 1
+                draw_data(data, [LIGHT_GREEN for x in range(len(temp))])
+                time.sleep(time_tick)
+    return draw_data(data, [BLUE for x in range(len(data))])

algorithms/bucketSort.py

@@ -11,6 +11,7 @@
 from algorithms.countingSort import counting_sort
 from algorithms.radixSort import radix_sort
 from algorithms.heapSort import heap_sort
+from algorithms.bucketSort import bucket_sort
 
 
 root = Tk()
@@ -28,7 +29,8 @@
     'Quick Sort', 
     'Counting Sort', 
     'Radix Sort', 
-    'Heap Sort'
+    'Heap Sort',
+    'Bucket Sort'
 ]
 
 speed_name = StringVar()
@@ -91,6 +93,8 @@ def sort():
         radix_sort(data, draw_data, time_tick)
     elif algorithm_menu.get() == 'Heap Sort':
         heap_sort(data, draw_data, time_tick)
+    elif algorithm_menu.get() == 'Bucket Sort':
+        bucket_sort(data, len(data), draw_data, time_tick)
     else: 
         pass