一、计数排序
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;
}
优化后的算法
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;
}
3.算法分析
- 最好、最坏、平均时间复杂度为O(N + k),k 是临时数组的长度
- 空间复杂度为O(k)
- 是稳定的算法
二、桶排序
1.基本思想
桶排序(箱排序)思想与计数排序类似,将最大值与最小值之间的空间平均分为M个桶,将元素按某种映射关系 f 放入对应的桶中,只是一个桶里可能装了多个元素,需要对每个桶内的元素再进行一次比较排序(可使用快速排序)
- 桶内部的元素存储方式为LinkedList,桶的存储方式为ArrayList
- 映射关系要尽可能将元素平均分到每个桶中
- 一般取映射关系 f = a[i] / k, k = sqrt(n)
- 桶的个数选取有两种方式:10n或2n、取最大值最小值均分作桶
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;
}
3.算法分析
- 算法的平均、最好时间复杂度为O(n + k),最坏 时间复杂度为O(n2),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();
}
}
}
3.算法分析
- 最低位优先使用的桶数量远小于最高位优先
- 时间复杂度为O(N*k),k是桶的个数
- 空间复杂度为O(N + k)
- 需要辅助数组
- 是稳定的排序