Bucket Sort

Bucket sort is mainly useful when input is uniformly distributed over a range. For example, consider the following problem. 
Sort a large set of floating point numbers which are in range from 0.0 to 1.0 and are uniformly distributed across the range. How do we sort the numbers efficiently?
A simple way is to apply a comparison based sorting algorithm. The lower bound for Comparison based sorting algorithm (Merge Sort, Heap Sort, Quick-Sort .. etc) is Ω(n Log n), i.e., they cannot do better than nLogn. 
Can we sort the array in linear time? Counting sort can not be applied here as we use keys as index in counting sort. Here keys are floating point numbers.  
The idea is to use bucket sort. Following is bucket algorithm.
 

bucketSort(arr[], n)
1) Create n empty buckets (Or lists).
2) Do following for every array element arr[i].
.......a) Insert arr[i] into bucket[n*array[i]]
3) Sort individual buckets using insertion sort.
4) Concatenate all sorted buckets.

 

BucketSort

Time Complexity: If we assume that insertion in a bucket takes O(1) time then steps 1 and 2 of the above algorithm clearly take O(n) time. The O(1) is easily possible if we use a linked list to represent a bucket (In the following code, C++ vector is used for simplicity). Step 4 also takes O(n) time as there will be n items in all buckets. 
The main step to analyze is step 3. This step also takes O(n) time on average if all numbers are uniformly distributed (please refer CLRS book for more details)
Following is the implementation of the above algorithm.
 

C/C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to sort an array using bucket sort
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
  
// Function to sort arr[] of size n using bucket sort
void bucketSort(float arr[], int n)
{
    // 1) Create n empty buckets
    vector<float> b[n];
  
    // 2) Put array elements in different buckets
    for (int i = 0; i < n; i++) {
        int bi = n * arr[i]; // Index in bucket
        b[bi].push_back(arr[i]);
    }
  
    // 3) Sort individual buckets
    for (int i = 0; i < n; i++)
        sort(b[i].begin(), b[i].end());
  
    // 4) Concatenate all buckets into arr[]
    int index = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < b[i].size(); j++)
            arr[index++] = b[i][j];
}
  
/* Driver program to test above function */
int main()
{
    float arr[] = { 0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434 };
    int n = sizeof(arr) / sizeof(arr[0]);
    bucketSort(arr, n);
  
    cout << "Sorted array is \n";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java program to sort an array 


// using bucket sort 


import java.util.*; 


import java.util.Collections; 


  


class GFG { 


  


    // Function to sort arr[] of size n 


    // using bucket sort 


    static void bucketSort(float arr[], int n) 


    { 


        if (n <= 0) 


            return; 


  


        // 1) Create n empty buckets 


        @SuppressWarnings("unchecked") 


        Vector<Float>[] buckets = new Vector[n]; 


  


        for (int i = 0; i < n; i++) { 


            buckets[i] = new Vector<Float>(); 


        } 


  


        // 2) Put array elements in different buckets 


        for (int i = 0; i < n; i++) { 


            float idx = arr[i] * n; 


            buckets[(int)idx].add(arr[i]); 


        } 


  


        // 3) Sort individual buckets 


        for (int i = 0; i < n; i++) { 


            Collections.sort(buckets[i]); 


        } 


  


        // 4) Concatenate all buckets into arr[] 


        int index = 0; 


        for (int i = 0; i < n; i++) { 


            for (int j = 0; j < buckets[i].size(); j++) { 


                arr[index++] = buckets[i].get(j); 


            } 


        } 


    } 


  


    // Driver code 


    public static void main(String args[]) 


    { 


        float arr[] = { (float)0.897, (float)0.565, 


                        (float)0.656, (float)0.1234, 


                        (float)0.665, (float)0.3434 }; 


  


        int n = arr.length; 


        bucketSort(arr, n); 


  


        System.out.println("Sorted array is "); 


        for (float el : arr) { 


            System.out.print(el + " "); 


        } 


    } 


} 


  


// This code is contributed by Himangshu Shekhar Jha 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 program to sort an array  


# using bucket sort  


def insertionSort(b): 


    for i in range(1, len(b)): 


        up = b[i] 


        j = i - 1


        while j >= 0 and b[j] > up:  


            b[j + 1] = b[j] 


            j -= 1


        b[j + 1] = up      


    return b      


              


def bucketSort(x): 


    arr = [] 


    slot_num = 10 # 10 means 10 slots, each 


                  # slot's size is 0.1 


    for i in range(slot_num): 


        arr.append([]) 


          


    # Put array elements in different buckets  


    for j in x: 


        index_b = int(slot_num * j)  


        arr[index_b].append(j) 


      


    # Sort individual buckets  


    for i in range(slot_num): 


        arr[i] = insertionSort(arr[i]) 


          


    # concatenate the result 


    k = 0


    for i in range(slot_num): 


        for j in range(len(arr[i])): 


            x[k] = arr[i][j] 


            k += 1


    return x 


  


# Driver Code 


x = [0.897, 0.565, 0.656, 


     0.1234, 0.665, 0.3434]  


print("Sorted Array is") 


print(bucketSort(x)) 


  


# This code is contributed by 


# Oneil Hsiao 



















                        chevron_right







                        filter_none










Output: 




Sorted array is
0.1234 0.3434 0.565 0.656 0.665 0.897


Bucket Sort To Sort an Array with Negative Numbers
References: 
Introduction to Algorithms 3rd Edition by Clifford Stein, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest 
http://en.wikipedia.org/wiki/Bucket_sort 
  





Snapshots: 
 


scene00505


 


scene01009


 


scene01513


 




scene01729


 


scene01801


 


scene01945


 


scene02017


 


scene02521


Quiz on Bucket Sort


Other Sorting Algorithms on GeeksforGeeks/GeeksQuiz:



Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above


Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.





    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:


					
		

    Article Tags : 
Sorting

           	
Practice Tags : 
Sorting

        

         

         
 
                19

                

        



        
        
        
        
        

    

            

            2.2
            

            

             
                 Based on 62 vote(s)
                    

            
            
            
            
            
        

        
        

        

        

        

        

        

        


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.