排序算法总结之桶排序 Bucket Sort

算法原理：

桶排序假设输入数据服从均匀分布，假设输入数据由一个随机过程产生，该过程将元素均匀，独立地分布在[0,1)区间上。将[0,1)区间划分为n个相同大小的子区间，称为“桶”，然后便利输入的数据，分别放入在制定的同种，然后依次把各个桶中的数据输出。

算法伪代码：

BUCKET-SORT(A)

let B[0..n-1] be a new array

n <- length[A]

for i=0 to n-1

make B[i] an empty list

for i=1 to n

insert A[i] into list B[nA[i]]

for i=0 to n-1

sort list B[i] with insertion sort

concatenate the lists B[0], B[1]...B[n-1] together in order

算法性能分析：

时间复杂度分析：

对n个元素进行桶排序的时间复杂度分为两个部分：

1. 循环计算每个元素的桶映射函数，时间复杂度为O(n )

2. 利用插入排序算法对每个桶内的所有数据进行排序，时间复杂度为 ∑ O(Ni*logNi)。其中Ni为第i个桶的数据量

因此，第2部分的性能是桶排序性能的决定因素。尽量做到两点：

1.  应设函数能够将n个数据平均的分配到m个桶中，每个桶有[n/m]的数据量

2. 尽量增大桶的数量。极限情况下每个通只得到一个数据，这样就完全避开了桶内数据的比较排序操作。数据量巨大的情况下，空间浪费严重，需要在时间代价和空间代价上做权衡。

当n=m，极限情况下每个通只有一个数据时，桶排序的效率达到O(n)

空间复杂度分析：O(n+m)

稳定性：稳定

Java版本代码：

private void bucketsort(double[] A)
	{
		int n = A.length;
		ArrayList<Double>[] list = new ArrayList[n];
		
		for(int i=0;i<n;i++)
		{
			int temp = (int)Math.floor(n*A[i]);
			if(list[temp]==null)
				list[temp] = new ArrayList<Double>();
			list[temp].add(A[i]);
		}
		
		for(int i=0;i<n;i++)
			if(list[i]!=null)
				insertionsort(list[i]);
		
		int count = 0;
		for(int i=0;i<n;i++)
		{
			if(list[i]!=null)
			{
				Iterator it = list[i].iterator();
				while(it.hasNext())
				{
					A[count] = (Double)it.next();
					count++;
				}
			}
		}
	}
	
	private void insertionsort(ArrayList<Double> B)
	{
		if(B.size()>1)
		{
			for(int i=1;i<B.size();i++)
			{
				double key = B.get(i);
				int j=i-1;
				while(j>=0 && B.get(j)>key)
				{
					B.set(j+1, B.get(j));
					j--;
				}
				B.set(j+1, key);
			}
		}
	}