The bucket sort algorithm is an advanced sorting technique, in contrast to others. Bucket sort can be considered as a collective framework built using a variety of sorting algorithms.
For example, you can use one of the types of algorithms to sort elements into buckets and another to sort elements within buckets. You could even recursively implement the algorithm you initially chose to sort each bucket to minimize lines of code.
Because of this adaptability, bucket sorting becomes slightly more complex but also the most versatile.
What Is a Bucket Sort Algorithm?
Bucket sort, also known as bin sort, is a sorting algorithm that divides an array's elements into several buckets. The buckets are then sorted one at a time, either using a different sorting algorithm or by recursively applying the bucket sorting algorithm.
The bucket sort method is as follows:
 Create an array of "buckets" that are initially empty
 Scatter: Go through the original array, placing each object in its appropriate bucket
 Each nonempty bucket should be sorted
 Gather: Return all elements to the original array after visiting the buckets in order
Moving ahead with this tutorial, you will now look at how the bucket sort algorithm works.
Working of a Bucket Sort Algorithm
The bucket sort algorithm works as follows.
 Assume the input array is:
If you take an integer as input, you must divide them by ten to obtain the floor value.
Make a onedimensional array of size ten and fill it with zeros at first. Each array slot serves as a bucket for storing elements.
 Insert array elements into the buckets. The elements are inserted following the bucket's range.
The example code has buckets ranging from 0 to 1, 1 to 2, 2 to 3,.... (n1) to n.
Assume that an input element with a value of.34 is chosen. It is multiplied by size = 10 (.34*10=3.4). Then it is converted into an integer. Finally,.34 is inserted into bucket 3.
Similarly,0.39 is placed in the same bucket. Every time, the floatingpoint number's floor value is taken.
 Each bucket's elements are sorted using one of the stable sorting algorithms.
 Each bucket's elements are gathered.
It is accomplished by iterating through the bucket and inserting one element at a time into the original array. When an element from the bucket is copied into the original array, it is erased.
Following the understanding of the its working procedure, you will now look at the pseudocode of the bucket sort algorithm.
Pseudocode and an Algorithm of the Bucket Sort Algorithm
Pseudocode of the Bucket Sort
function bucket_sort (list, B) is // list is the name of the array buckets < new array of B empty lists A < the array's maximum key value for i = 1 to length( list ) do Insert array[i[ into buckets [ floor ( B * list[i] / A) ] for i to B do Sort buckets[i] Return the gatttreation of buckets[1], buckets[2],...............buckets[B] 
Let list denote the array to be sorted, and B the number of buckets used. The maximum key value in linear time can be computed by iterating over all the keys once. Use the floor function to convert a floating number to an integer. Sort is a sorting function that is used to order each bucket. In most cases, insertion sort is used, but other algorithms, such as selection sort and merge sort, can also be used.
Algorithm of the Bucket Sort
bucket _Sort_Algorithm () Make B buckets, each of which can store a range of values for all of the buckets. Fill each bucket with 0 values for all buckets. Put elements in buckets that match the range for all buckets. Sort elements in each bucket and gather elements from each bucket end bucket_Sort_Algorithm() 
You will now learn about the complexity of the bucket sort.
The complexity of the Bucket Sort Algorithm
The Time Complexity of the Bucket Sort Algorithm
Bucket Sort's time complexity is largely determined by the size of the bucket list as well as the range over which the array/element lists have been distributed.
Best Case Complexity O(n)
 It occurs when the elements are distributed uniformly in the buckets, with nearly identical elements in each bucket.
 When the elements within the buckets are already sorted, the complexity increases.
 If insertion sort is used to sort bucket elements, the overall complexity will be linear, i.e. O(n+k).
 O(n) is the complexity of creating buckets, and O(k) is the complexity of sorting bucket elements using algorithms with linear time complexity in the best case.
Average Case Complexity O(n)
 It happens when the array's elements are distributed at random.
 Bucket sorting takes linear time, even if the elements are not distributed uniformly.
 It holds until the sum of the squares of the bucket sizes is linear in terms of the total number of elements.
Worst Case Complexity O(n*n)
 When elements in the array are close in proximity, they are likely to be placed in the same bucket.
 As a result, some buckets may contain more elements than others.
 It makes the complexity dependent on the sorting algorithm used to sort the bucket's elements.
 When the elements are placed in reverse order, the complexity increases even more.
 When insertion sort is used to sort bucket elements, the time complexity becomes O (n2).
The Space Complexity of the Bucket Sort Algorithm
So the space complexity of the bucket sort is O(n+k).
Following the understanding of the complexity of the bucket sort, you will now see some of its variants.
Variations of Bucket Sort Algorithm
The bucket sort has the following variations:

Postman's Sort
The algorithm works by sorting the numbers from the most significant to the least significant digit. Sorting the numbers on more than one digit at a time results in a significant increase in speed.
Postman's sort is a bucket sort variant that takes advantage of a hierarchical structure of elements, typically described by a set of attributes.
Lettersorting machines in post offices use the following algorithm: Mail is first separated into domestic and international categories, then by state, province, or territory, then by the destination post office, then by routes, and so on.

Histogram Sort
A histogram is a rough representation of the numerical data distribution. Karl Pearson was the first to use it. The first step in creating a histogram is to "bin" (or "bucket") the range of values, which means dividing the entire range of values into a series of intervals and then counting how many values fall into each interval.
The following variant of bucket sort, known as histogram sort or counting sort, includes a first pass that counts the number of elements placed into each bucket using a count array.
Using these details, the array values can be arranged into buckets utilizing a series of exchanges, leaving no room for bucket storage overhead.

Proxmap Sort
ProxMap Sorting takes a unique approach to sort that is conceptually similar to hashing. This method employs a variation on hashing with buckets, but with buckets of varying sizes.
ProxmapSort works in the same way as bucket sort in that it divides an array of keys into subarrays using a "map key" function that preserves a partial ordering on the keys; as each key is added to its subarray, insertion sort is used to keep that subarray sorted, resulting in the entire array being in sorted order when ProxmapSort finishes.

Generic Bucket Sort
The most common bucket sort variant takes a list of n numeric inputs ranging from zero to some maximum value M and divides the value range into n buckets of size M/n each. If each bucket is sorted using insertion sort, the sort can be demonstrated to take the expected linear time.
Following your understanding of the bucket sort algorithm's variations, you will now compare the bucket sort to other sorting algorithms.
Comparison of Bucket Sort Algorithm With Other Algorithms
Here are some comparisons with other sorting algorithms.

Merge Sort
The nway merge sort algorithm, like bucket sort, begins by dividing the list into n sublists and sorting each one; however, the sublists made by mergesort have overlapping value ranges and thus cannot be recombined by simple concatenation. Instead, a merge algorithm must interleave them.

Counting Sort
Bucket sort is a generalization of counting sort; in fact, bucket sort degenerates to counting sort if each bucket has size 1. Bucket sort's variable bucket size allows it to use O(n) memory rather than O(m) memory, where m is the number of different values; in exchange, it forgoes counting sort's O(n + m) worstcase behavior.

Radix Sort
Topdown radix sort is a subset of bucket sort in which both the range of values and the number of buckets are limited to powers of two. As a result, the size of each bucket is also a power of two, and the procedure can be repeated. This method can shorten the scatter phase because we only need to examine each element's bit representation prefix to determine its buckets.

Quick Sort
Bucket sort with two buckets is essentially a quicksort variant in which the pivot value is always chosen to be the median value of the value range. While this method works well for uniformly distributed inputs, other forms of selecting the pivot in quicksort, such as randomly chosen pivots, make the input distribution more resistant to clustering.
In the next section of this tutorial, you will see some applications of the bucket sort algorithm.
Applications of Bucket Sort Algorithm
When bucket sorting is used, one of the following conditions must be met:
 Bucket sorting is based on the assumption that the input is drawn from a uniform distribution.
 Because of the way elements are assigned to buckets, typically using an array where the index is the value, bucket sorting can be extremely fast.
 This means that more auxiliary memory for the buckets is required at the expense of running time than more comparison sorts.
 By dividing data into small buckets that can be sorted individually, the number of comparisons that must be performed is reduced.
Code Implementation of Bucket Sort Algorithm
#include <stdio.h> #include<conio.h> #include<stdlib.h> int Max(int list[], int length) { int maximum = list[0]; for (int i = 1; i < length; i++) if (list[i] > maximum) maximum = list[i]; return maximum; } void bucketSortAlgorithm(int list[], int length) { int bucket[10]; const int maximum = Max(list, length); for (int i = 0; i <= maximum; i++) { bucket[i] = 0; } for (int i = 0; i < length; i++) { bucket[list[i]]++; } for (int i = 0, j = 0; i <= maximum; i++) { while (bucket[i] > 0) { list[j++] = i; bucket[i]; } } } void display_Array(int list[], int length) { for (int i = 0; i < length; ++i) { printf("%d ", list[i]); } printf("\n"); } int main() { int elements[] = {9, 5, 3, 5, 6, 7, 9, 4}; int length = sizeof(elements) / sizeof(elements[0]); bucketSortAlgorithm(elements, length); printf("After sorting in ascending order: \n"); display_Array(elements, length); } 
Output:
Advance your career as a MEAN stack developer with the Full Stack Web Developer  MEAN Stack Master's Program. Enroll now!
Next Steps
Your next topic will be the bubble sort algorithm, which you will go over in great detail.
If you are perhaps looking for a comprehensive workready training that covers frontend, middleware and backend development technologies, Simplilearn’s Post Graduate Program in Full Stack Web Development is the one you should be looking at. This course offers you an indepth study that goes beyond Data Structure and covers the most indemand programming languages and abilities today. It's time to go out and explore.
Do you have any further queries about the Bucket Sort Algorithm? If you do, please leave them in the comments section at the bottom of this page. Our experts will get back to you as quickly as possible!