利用了函式的對映關係，高效與否的關鍵就在於這個對映函式的確定。為了使桶排序更加高效，我們需要做到這兩點：

1. 在額外空間充足的情況下，儘量增大桶的數量
2. 使用的對映函式能夠將輸入的 N 個數據均勻的分配到 K 個桶中

JavaScript

 1 function bucketSort(arr, bucketSize) {
 2     if (arr.length === 0) {
 3       return arr;
 4     }
 5 
 6     var i;
 7     var minValue = arr[0];
 8     var maxValue = arr[0];
 
 9     for (i = 1; i < arr.length; i++) {
10       if (arr[i] < minValue) {
11           minValue = arr[i];                // 輸入資料的最小值
12       } else if (arr[i] > maxValue) {
13           maxValue = arr[i];                // 輸入資料的最大值
14       }
15     }
16 
17     //桶的初始化
18     var DEFAULT_BUCKET_SIZE = 5;            //
 
 設定桶的預設數量為5
19     bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
20     var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;   
21     var buckets = new Array(bucketCount);
22     for (i = 0; i < buckets.length; i++) {
23         buckets[i] = [];
24     }
25 
26     //利用對映函式將資料分配到各個桶中
 

27     for (i = 0; i < arr.length; i++) {
28         buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
29     }
30 
31     arr.length = 0;
32     for (i = 0; i < buckets.length; i++) {
33         insertionSort(buckets[i]);                      // 對每個桶進行排序，這裡使用了插入排序
34         for (var j = 0; j < buckets[i].length; j++) {
35             arr.push(buckets[i][j]);                      
36         }
37     }
38 
39     return arr;
40 }

Python

 1 def bucket_sort_simplify(arr, max_num):
 2     buf = {i: [] for i in range(int(max_num)+1)}  # 不能使用[[]]*(max+1)，這樣新建的空間中各個[]是共享記憶體的
 3     arr_len = len(arr)
 4     for i in range(arr_len):
 5         num = arr[i]
 6         buf[int(num)].append(num)  # 將相應範圍內的資料加入到[]中
 7     arr = []
 8     for i in range(len(buf)):
 9         if buf[i]:
10             arr.extend(sorted(buf[i]))  # 這裡還需要對一個範圍內的資料進行排序，然後再進行輸出
11     return arr
12 
13 
14 if __name__ == "__main__":
15     lis = [3.1, 4.2, 3.3, 3.5, 2.2, 2.7, 2.9, 2.1, 1.55, 4.456, 6.12, 5.2, 5.33, 6.0, 2.12]
16     print(bucket_sort_simplify(lis, max(lis)))

C++

 1 #include<iterator>
 2 #include<iostream>
 3 #include<vector>
 4 using namespace std;
 5 const int BUCKET_NUM = 10;
 6 
 7 struct ListNode{
 8         explicit ListNode(int i=0):mData(i),mNext(NULL){}
 9         ListNode* mNext;
10         int mData;
11 };
12 
13 ListNode* insert(ListNode* head,int val){
14         ListNode dummyNode;
15         ListNode *newNode = new ListNode(val);
16         ListNode *pre,*curr;
17         dummyNode.mNext = head;
18         pre = &dummyNode;
19         curr = head;
20         while(NULL!=curr && curr->mData<=val){
21                 pre = curr;
22                 curr = curr->mNext;
23         }
24         newNode->mNext = curr;
25         pre->mNext = newNode;
26         return dummyNode.mNext;
27 }
28 
29 
30 ListNode* Merge(ListNode *head1,ListNode *head2){
31         ListNode dummyNode;
32         ListNode *dummy = &dummyNode;
33         while(NULL!=head1 && NULL!=head2){
34                 if(head1->mData <= head2->mData){
35                         dummy->mNext = head1;
36                         head1 = head1->mNext;
37                 }else{
38                         dummy->mNext = head2;
39                         head2 = head2->mNext;
40                 }
41                 dummy = dummy->mNext;
42         }
43         if(NULL!=head1) dummy->mNext = head1;
44         if(NULL!=head2) dummy->mNext = head2;
45         
46         return dummyNode.mNext;
47 }
48 
49 void BucketSort(int n,int arr[]){
50         vector<ListNode*> buckets(BUCKET_NUM,(ListNode*)(0));
51         for(int i=0;i<n;++i){
52                 int index = arr[i]/BUCKET_NUM;
53                 ListNode *head = buckets.at(index);
54                 buckets.at(index) = insert(head,arr[i]);
55         }
56         ListNode *head = buckets.at(0);
57         for(int i=1;i<BUCKET_NUM;++i){
58                 head = Merge(head,buckets.at(i));
59         }
60         for(int i=0;i<n;++i){
61                 arr[i] = head->mData;
62                 head = head->mNext;
63         }
64 }