初始计数排序
摘自漫画算法：
计数排序是一种不基于元素比较，利用数组索引来确定元素的正确位置的。
假设数组中有20个随机整数，取值范围0~10，要求用最快的速度把这20个整数从小到大进行排序。
如何给这些无序的随机整数进行排序呢？
考虑到这些整数只能够在0、1、2、3、4、5、6、7、8、9、10这11个数中取值，取值范围有限。所以，可以根据这有限的范围，建立一个长度为11的数组。数组索引从0到10，元素初始值全为0。
假设20个随机整数的值如下所示：
9、3、5、4、9、1、2、7、8、1、3、6、5、3、4、0、10、9、7、9
下面就开始遍历这个无序的随机数列，每一个整数按照其值对号入座，同时，对应数组索引的元素进行加1操作。
例如第1个整数是9，那么数组索引为9的元素加1。
第2个整数是3，那么数组索引为3的元素加1。
以此类推。最终，当数列遍历完毕时，数组的状态如下：
该数组中每一个索引位置的值代表数列中对应整数出现的次数。
有了这个统计结果，排序就很简单了。直接遍历数组，输出数组元素的索引值，元素的值是几，就输出几次。
0，1，1，2，3，3，3，4，4，5，5，6，7，7，8，9，9，9，9，10
显然，现在输出的数列已经是有序的了。
注意：计数排序它适用于一定范围内的整数排序。在取值范围不是很大的情况下，它的性能甚至快过那些时间复杂度为O(nlogn)的排序。
计数排序的实现
整体代码
import java.util.Arrays;
/**
* 描述：计数排序
* <p>
* Create By ZhangBiao
* 2020/5/31
*/
public class CountSort {
/**
* 计数排序
*
* @param arr
* @return
*/
public static int[] countSort(int[] arr) {
// 1、得到数列的最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 2、根据数列最大值确定统计数组的长度
int[] countArray = new int[max + 1];
// 3、遍历数列，填充统计数组
for (int i = 0; i < arr.length; i++) {
countArray[arr[i]]++;
}
// 4、遍历统计数组，输出结果
int index = 0;
int[] sortedArray = new int[arr.length];
for (int i = 0; i < countArray.length; i++) {
for (int j = 0; j < countArray[i]; j++) {
sortedArray[index++] = i;
}
}
return sortedArray;
}
public static void main(String[] args) {
int[] arr = new int[]{4, 4, 6, 5, 3, 2, 8, 1, 7, 5, 6, 0, 10};
int[] sortedArray = countSort(arr);
System.out.println(Arrays.toString(sortedArray));
}
}
这段代码在开头有一个步骤，就是求数列的最大整数值max。后面创建的统计数组countArray，长度是max+1，以此来保证数组的最后一个下标是max。
计数排序的优化
从实现功能的角度来看，这段代码可以实现整数的排序。但是这段代码也存在一些问题。
当以数列的最大值来决定统计数组的长度，其实并不严谨。例如下面的数列：
95、94、91、98、99、90、99、93、91、92
在这个数列中最大值是99，但最小的整数是90。如果创建长度为100的数组，那么前面从0到89的空间位置就都浪费了！
怎么解决这个问题呢？
很简单，只要不再以输入数列的最大值+1作为统计数组的长度，而是以数列最大值 - 最小值 + 1作为统计数组的长度即可。
同时，数列的最小值作为一个偏移量，用于计算整数在统计数组中的索引。
以刚才的数列为例，统计出数组的长度为99 - 90 + 1 = 10，偏移量等于数列的最小值90。对于第1个整数95，对应的统计数组索引时95 - 90 = 5。
如图所示：
注意：以上确实对计数排序进行了优化。此外，朴素版的计数排序只是简单地按照统计数组的索引输出元素值，并没有真正给原始数列进行排序。
如果只是单纯地给整数排序，这样做并没有问题。但如果在现实业务里，例如给学生的考试分数进行排序，遇到相同的分数就会分不清是谁。
什么意思呢？让我们看看下面的例子。
| 姓名 | 成绩 |
|---|---|
| 小灰 | 90 |
| 大黄 | 99 |
| 小红 | 95 |
| 小白 | 94 |
| 小绿 | 95 |
给出一个学生成绩表，要求按照成绩从高到底进行排序，如果成绩相同，则遵循原表固有顺序。
那么，当我们填充统计数组以后，只知道有两个成绩并列为95分的同学，却不知道哪一个是小红，哪一个是小绿。
那么如何解决呢？在这种情况下，需要稍微改变之前的逻辑，在填充完统计数组以后，对统计数组做一下变形。
仍然以刚才的学生成绩为例，将之前的统计数组变形成下面的样子。
这是如何变形的呢？其实就是从统计数组的第2个元素开始，每一个元素都加上前面所有元素之和。
为什么要相加呢？初次接触的读者可能会觉得莫名其妙。
这样相加的目的，是让统计数组存储的元素值，等于相应整数的最终排序位置的序号。例如索引是9的元素值为5，代表原始数列的整数9，最终的排序在第5位。
接下来，创建输出数组sortedArray，长度和输入数列一致。然后从后向前遍历输入数列。
第1步，遍历成绩表最后一行的小绿同学的成绩。
小绿的成绩是95分，找到countArray索引是5的元素，值是4，代表小绿的成绩排名位置在第4位。
同时，给countArray索引是5的元素值减1，从4变成3，代表下次再遇到95分的成绩时，最终排名是第3.
| 姓名 | 成绩 |
|---|---|
| 小灰 | 90 |
| 大黄 | 99 |
| 小红 | 95 |
| 小白 | 94 |
| 小绿 | 95 |
第2步，遍历成绩倒数第2行的小白同学的成绩。
小白的成绩是94分，找到countArray索引是4的元素，值是2，代表小白的成绩排名位置在第2位。
同时，给countArray索引是4的元素值减1，从2变成1，代表下次再遇到94分的成绩时（实际上已经遇不到了），最终排名是1。
第3步，遍历成绩表倒数第2行的小红同学的成绩。
小红的成绩是95分，找到countArray索引是5的元素，值是3（最初是4，减1变成了3），代表小红的成绩排名位置在第3位。同时，给countArray索引是5的元素值减1，从3变成2，代表下次再遇到95分的成绩时（实际上已经遇不到了），最终排名是第2。
这样一来，同样是95分的小红和小绿就能够清除地排出顺序了，也正因为此，优化版本的计数排序属于稳定排序。
后面的遍历过程以此类推，这里就不再详细描述了。
整体实现代码：
import java.util.Arrays;
/**
* 描述：计数排序
* <p>
* Create By ZhangBiao
* 2020/5/31
*/
public class CountSort {
/**
* 计数排序
*
* @param arr
* @return
*/
public static int[] countSort(int[] arr) {
// 1、得到数列的最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 2、根据数列最大值确定统计数组的长度
int[] countArray = new int[max + 1];
// 3、遍历数列，填充统计数组
for (int i = 0; i < arr.length; i++) {
countArray[arr[i]]++;
}
// 4、遍历统计数组，输出结果
int index = 0;
int[] sortedArray = new int[arr.length];
for (int i = 0; i < countArray.length; i++) {
for (int j = 0; j < countArray[i]; j++) {
sortedArray[index++] = i;
}
}
return sortedArray;
}
/**
* 优化后的计数排序
*
* @param arr
* @return
*/
public static int[] countSort2(int[] arr) {
// 1、得到数列的最大值和最小值，并算出差值d
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
int d = max - min;
// 2、创建统计数组并统计对应元素的个数
int[] countArray = new int[d + 1];
for (int i = 0; i < arr.length; i++) {
countArray[arr[i] - min]++;
}
// 3、统计数组做变形，后面的元素等于前面的元素之和
for (int i = 1; i < countArray.length; i++) {
countArray[i] += countArray[i - 1];
}
// 4、倒序遍历原始数列，从统计数组找到正确位置，输出到结果数组
int[] sortedArray = new int[arr.length];
for (int i = arr.length - 1; i >= 0; i--) {
sortedArray[countArray[arr[i] - min] - 1] = arr[i];
countArray[arr[i] - min]--;
}
return sortedArray;
}
public static void main(String[] args) {
int[] arr = new int[]{95, 94, 91, 98, 99, 90, 99, 93, 91, 92};
int[] sortedArray = countSort2(arr);
System.out.println(Arrays.toString(sortedArray));
}
}
计数排序的局限性
1、当数列最大和最小值差距过大时，并不适合用计数排序
例如给出20个随机数，范围在0到1亿之间，这时如果使用计数排序，需要创建长度为1亿的数组。不但严重浪费空间，而且时间复杂度也会随之升高。
2、当数列元素不是整数时，也不适合用计数排序
如果数列中的元素都是小数，如25.213，或0.00 000 001这样的数字，则无法创建对应的统计数组。这样显然无法进行计数排序。
对于这些局限性，另一种线性时间排序算法做出了弥补，这种排序算法叫做桶排序。
