桶排序

元素分配到桶中
对桶中元素排序
桶排序（Bucket sort）或所谓的箱排序，是一个排序演算法，工作的原理是将阵列分到有限数量的桶里。每个桶再个别排序（有可能再使用别的排序演算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一般化(generalization)。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（）。
桶排序以下列程序进行：
# 设置一个定量的阵列当作空桶子。
# 寻访序列，并且把项目一个一个放到对应的桶子去。
# 对每个不是空的桶子进行排序。
# 从不是空的桶子里把项目再放回原来的序列中。

**伪代码**
function bucket-sort(array, n) is
buckets ← new array of n empty lists
for i = 0 to (length(array)-1) do
insert arrayi into bucketsmsbits(arrayi, k)
for i = 0 to n - 1 do
next-sort(bucketsi)
return the concatenation of buckets0, ..., bucketsn-1

**C++实现算法**
假设数据分布在0，100)之间，每个桶内部用链表表示，在数据入桶的同时插入排序。然后把各个桶中的数据合并。
#include
#include
#include
using namespace std;
const int BUCKET_NUM = 10;
struct ListNode{
	explicit ListNode(int i=0):mData(i),mNext(NULL){}
	ListNode* mNext;
	int mData;
};
ListNode* insert(ListNode* head,int val){
	ListNode dummyNode;
	ListNode *newNode = new ListNode(val);
	ListNode *pre,*curr;
	dummyNode.mNext = head;
	pre = &dummyNode;
	curr = head;
	while(NULL!=curr && curr->mDatamNext;
	}
	newNode->mNext = curr;
	pre->mNext = newNode;
	return dummyNode.mNext;
}
ListNode* Merge(ListNode *head1,ListNode *head2){
	ListNode dummyNode;
	ListNode *dummy = &dummyNode;
	while(NULL!=head1 && NULL!=head2){
		if(head1->mData mData){
			dummy->mNext = head1;
			head1 = head1->mNext;
		}else{
			dummy->mNext = head2;
			head2 = head2->mNext;
		}
		dummy = dummy->mNext;
	}
	if(NULL!=head1) dummy->mNext = head1;
	if(NULL!=head2) dummy->mNext = head2;
	
	return dummyNode.mNext;
}
void BucketSort(int n,int arr){
	vector buckets(BUCKET_NUM,(ListNode*)(0));
	for(int i=0;imData;
		head = head->mNext;
	}
}

**Java实现算法**
	private int indexFor(int a, int min, int step) {
		return (a - min) / step;
	}
	public void bucketSort(int arr) {
		int max = arr0, min = arr0;
		for (int a : arr) {
			if (max  a)
				min = a;
		}
		// 该值也可根据实际情况选择
		int bucketNum = max / 10 - min / 10 + 1;
		List buckList = new ArrayList>();
		// create bucket
		for (int i = 1; i ());
		}
		// push into the bucket
		for (int i = 0; i ) buckList.get(index)).add(arri);
		}
		ArrayList bucket = null;
		int index = 0;
		for (int i = 0; i ) buckList.get(i);
			insertSort(bucket);
			for (int k : bucket) {
				arrindex++ = k;
			}
		}
	}
	// 把桶内元素插入排序
	private void insertSort(List bucket) {
		for (int i = 1; i = 0 && bucket.get(j) > temp; j--) {
				bucket.set(j + 1, bucket.get(j));
			}
			bucket.set(j + 1, temp);
		}
	}

**JavaScript实现算法**
Array.prototype.bucketSort = function(num) {
function swap(arr, i, j) {
const temp = arri
arri = arrj
arrj = temp
}
const max = Math.max(...this)
const min = Math.min(...this)
const buckets = 
const bucketsSize = Math.floor((max - min) / num) + 1
for(let i = 0; i  0) {
bucketsindexl 

**JavaScript实现递归算法**
Array.prototype.bucketSort = function()
{
var start = 0;
var size = this.length;
var min = this0;
var max = this0; 
for (var i = 1; i  max){max = thisi;} }
}
if (min != max){
var bucket = new Array(size);
for (var i = 0; i  1){bucketi.bucketSort();}//递归
for(var j = 0; j 

**Python 3.10 实现演算法**
def is_sort(arr: list) -> bool:
for i in range(len(arr) - 1):
if arri > arri + 1:
return False
return True
def bucket_sort(arr: list, is_sub_bucket: bool = False):
if is_sort(arr):
return
bucket_num: int = max(arr) // 10 + 1 if not is_sub_bucket else 10
buckets: listlist =  for _ in range(bucket_num)
for a in arr:
i: int = a // 10 if not is_sub_bucket else a % 10
bucketsi.append(a)

arr.clear()
for bucket in buckets:
bucket_sort(bucket, is_sub_bucket=True)
arr += bucket
if __name__ == '__main__':
arr = 29, 25, 3, 49, 9, 37, 21, 43
bucket_sort(arr)
print(arr)

**外部链接**
  Bucket Sort in C++-  Bucket Sort & PHP Samplefix-attempted=no 

**参考**
 Thomas H. Cormen，Charles E. Leiserson，Ronald L. Rivest，and Clifford Stein。Introduction to Algorithms, Second Edition. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Section 8.4: Bucket sort, pp.174–177.- Paul E. Black  "Postman's Sort" date=20061019164105  from Dictionary of Algorithms and Data Structures at NIST。- Robert Ramey  The Postman's Sort date=20061017022536  C Users Journal Aug. 1992