详解计数排序、桶排序与基数排序_桶排序与计数排序的区别

一、计数排序

1.基本思想

计数是一种适合元素均为大于等于零的整数，且最大值与最小值差值不大的排序
将数组元素作为数组下标，用一个临时数组统计每个元素出现的个数，再将临时数组从小到大输出，就得到了排序好的数组
比如 2，5，8，9，6，6，1这几个数排序，令临时数组长度为 10，当读入2时，count[2]++，所有数据读完后的count数组如下
count[0] = 0
count[1] = 1
count[2] = 1
count[3] = 0
count[4] = 0
count[5] = 1
count[6] = 2
count[7] = 0
count[8] = 1
count[9] = 1
输出这个数组就得到了排序后的数据：1，2，5，6，6，8，9

上面的思想中实质上临时数组的大小M要大于最大元素，但在一些情况下如数组为[1001，1002，1007]时，再使用上面的算法就会发现存在大量的无用空间，因此我们可以使临时数组大小为M = (Max - Min + 1)，用Min作为偏移量

2.算法实现

	public static void countingsort(int[] a)
	{
		//寻找最大值
		int max = 0;
		for(int i = 0; i < a.length; i++)
			if(max < a[i])
				max = a[i];
		
		//创建临时数组
		int[] count = new int[max + 1];
		
		//统计元素
		for(int i = 0; i < a.length; i++)
			count[a[i]]++;
		
		//输出临时数组所含信息
		int j = 0;
		for(int i = 0; i < count.length; i++)
			for(; count[i] != 0; count[i]--)
				a[j++] = i;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

优化后的算法

	public static void countingsort(int[] a)
	{
		//寻找最大值与最小值
		int max = 0;
		int min = 0;
		for(int i = 0; i < a.length; i++)
		{
			if(max < a[i])
				max = a[i];
			if(min > a[i])
				min = a[i];
		}
		
		//创建优化后的临时数组
		int[] count = new int[max - min + 1];
		
		//统计元素
		for(int i = 0; i < a.length; i++)
			count[a[i] - min]++;
		
		//输出临时数组所含信息
		int j = 0;
		for(int i = 0; i < count.length; i++)
			for(; count[i] != 0; count[i]--)
				a[j++] = i + min;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3.算法分析

• 最好、最坏、平均时间复杂度为O(N + k),k 是临时数组的长度
• 空间复杂度为O(k)
• 是稳定的算法

二、桶排序

1.基本思想

桶排序（箱排序）思想与计数排序类似，将最大值与最小值之间的空间平均分为M个桶，将元素按某种映射关系 f 放入对应的桶中，只是一个桶里可能装了多个元素，需要对每个桶内的元素再进行一次比较排序（可使用快速排序）

• 桶内部的元素存储方式为LinkedList，桶的存储方式为ArrayList
• 映射关系要尽可能将元素平均分到每个桶中
• 一般取映射关系 f = a[i] / k, k = sqrt(n)
• 桶的个数选取有两种方式：10ⁿ或2ⁿ、取最大值最小值均分作桶

2.算法实现

与优化后的计数排序相似，也使用偏移量

import java.util.*;

	public static void bucketsort(int[] a)
	{
		//寻找数组中的最大值与最小值
		int max = a[0];
		int min = a[0];
		for(int i = 1; i < a.length; i++)
		{
			if(max < a[i])
				max = a[i];

			if(min > a[i])
				min = a[i];

		}
		
		//初始化桶
		int bucketNum = (max - min)/a.length + 1;
		ArrayList<LinkedList<Integer>> bucket = new ArrayList<>(bucketNum);
		for(int i = 0; i < bucketNum; i++)
			bucket.add(new LinkedList<Integer>());
		
		//将元素装入对应的桶中
		for(int i = 0; i < a.length; i++)
		{
			int index = (a[i] - min)/a.length;
			bucket.get(index).add(a[i]);
		}
		
		//对每个桶内部进行排序
		for(int i = 0; i < bucket.size(); i++)
			Collections.sort(bucket.get(i));
				
		//将元素按顺序输出
		int k = 0;
		for(LinkedList<Integer> in : bucket)
			for(Integer x : in)
				a[k++] = x;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3.算法分析

• 算法的平均、最好时间复杂度为O(n + k)，最坏 时间复杂度为O(n²)，k为桶的个数
• 空间复杂度为O(n + k)
• 需要额外空间/辅助数组
• 稳定性取决于内部排序方式

三、基数排序

1.基本思想

基数排序是一种按位进行的桶排序，这样可以减少桶的数量。基数排序的第一步是将所有数值补为同样的位数长度，不够的前面补零

最高位优先：首先按照最高位对元素进行桶排序，一个桶里可能有多个元素，再将这个桶中的多个元素按次高位排序，递归地进行桶排序，直到每个元素都存在一个桶中，遍历就的到了排序后的数组

• 最高位优先尽管使用了比直桶排序更少数量的桶，但仍然过于麻烦，而且需要使用递归，大桶里有小桶，因此一般使用最低为优先

最低位优先：首先按照最低位进行桶排序，一个桶中的多个元素将一趟排序后的数组再进行次低位的桶排序，以此类推直到排完最高位，那么遍历数组就得到了排序好的元素

2.算法实现

import java.util.*;
	public static void radixsort(int[] a)
	{
		//寻找最大值
		int max = a[0];
		for(int i = 1; i < a.length; i++)
			if(max < a[i])
				max = a[i];
		
		//计算最高位有几位
		int maxFigure = 1;
		while(max / 10> 0)
		{
			maxFigure++;
			max /= 10;
		}
		
		//初始化桶
		ArrayList<LinkedList<Integer>> bucket = new ArrayList<>(10);
		for(int i = 0; i < 10; i++)
			bucket.add(new LinkedList<Integer>());
		
		//进行每一趟的排序，最低位优先
		for(int i = 1; i <= maxFigure; i++)
		{
			//获取每个元素最后第i位的值
			for(int j = 0; j < a.length; j++)
			{
				int val = (a[j] / (int)Math.pow(10, i - 1)) % 10;
				bucket.get(val).add(a[j]);
			}
			
			//一趟排序后将元素放入原数组
			int k = 0;
			for(int j = 0; j < 10; j++)
			{
				for(Integer x : bucket.get(j))
					a[k++] = x;
				//一趟排序后将桶清空
				bucket.get(j).clear();
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

3.算法分析

• 最低位优先使用的桶数量远小于最高位优先
• 时间复杂度为O（N*k）,k是桶的个数
• 空间复杂度为O(N + k)
• 需要辅助数组
• 是稳定的排序