01 计数排序算法概念
计数排序不是一个比较排序算法，该算法于1954年由 Harold H. Seward提出，通过计数将时间复杂度降到了O(N)。
02 基础版算法步骤
第一步：找出原数组中元素值最大的，记为max。
第二步：创建一个新数组count，其长度是max加1，其元素默认值都为0。
第三步：遍历原数组中的元素，以原数组中的元素作为count数组的索引，以原数组中的元素出现次数作为count数组的元素值。
第四步：创建结果数组result，起始索引index。
第五步：遍历count数组，找出其中元素值大于0的元素，将其对应的索引作为元素值填充到result数组中去，每处理一次，count中的该元素值减1，直到该元素值不大于0，依次处理count中剩下的元素。
第六步：返回结果数组result。
03 基础版代码实现
public int[] countSort(int[] A) { // 找出数组A中的最大值 int max = Integer.MIN_VALUE; for (int num : A) { max = Math.max(max, num); } // 初始化计数数组count int[] count = new int[max+1]; // 对计数数组各元素赋值 for (int num : A) { count[num]++; } // 创建结果数组 int[] result = new int[A.length]; // 创建结果数组的起始索引 int index = 0; // 遍历计数数组，将计数数组的索引填充到结果数组中 for (int i=0; i<count.length; i++) { while (count[i]>0) { result[index++] = i; count[i]--; } } // 返回结果数组 return result; }
04 优化版
基础版能够解决一般的情况，但是它有一个缺陷，那就是存在空间浪费的问题。
比如一组数据{101,109,108,102,110,107,103}，其中最大值为110，按照基础版的思路，我们需要创建一个长度为111的计数数组，但是我们可以发现，它前面的[0,100]的空间完全浪费了，那怎样优化呢？
将数组长度定为max-min+1，即不仅要找出最大值，还要找出最小值，根据两者的差来确定计数数组的长度。
public int[] countSort2(int[] A) { // 找出数组A中的最大值、最小值 int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE; for (int num : A) { max = Math.max(max, num); min = Math.min(min, num); } // 初始化计数数组count // 长度为最大值减最小值加1 int[] count = new int[max-min+1]; // 对计数数组各元素赋值 for (int num : A) { // A中的元素要减去最小值，再作为新索引 count[num-min]++; } // 创建结果数组 int[] result = new int[A.length]; // 创建结果数组的起始索引 int index = 0; // 遍历计数数组，将计数数组的索引填充到结果数组中 for (int i=0; i<count.length; i++) { while (count[i]>0) { // 再将减去的最小值补上 result[index++] = i+min; count[i]--; } } // 返回结果数组 return result; }
05 进阶版步骤
以数组A = {101,109,107,103,108,102,103,110,107,103}为例。
第一步：找出数组中的最大值max、最小值min。
第二步：创建一个新数组count，其长度是max-min加1，其元素默认值都为0。
第三步：遍历原数组中的元素，以原数组中的元素作为count数组的索引，以原数组中的元素出现次数作为count数组的元素值。
第四步：对count数组变形，新元素的值是前面元素累加之和的值，即count[i+1] = count[i+1] + count[i];。
第五步：创建结果数组result，长度和原始数组一样。
第六步：遍历原始数组中的元素，当前元素A[j]减去最小值min，作为索引，在计数数组中找到对应的元素值count[A[j]-min]，再将count[A[j]-min]的值减去1，就是A[j]在结果数组result中的位置，做完上述这些操作，count[A[j]-min]自减1。
是不是对第四步和第六步有疑问？为什么要这样操作？
第四步操作，是让计数数组count存储的元素值，等于原始数组中相应整数的最终排序位置，即计算原始数组中的每个数字在结果数组中处于的位置。
比如索引值为9的count[9]，它的元素值为10，而索引9对应的原始数组A中的元素为9+101=110（要补上最小值min，才能还原），即110在排序后的位置是第10位，即result[9] = 110，排完后count[9]的值需要减1，count[9]变为9。
再比如索引值为6的count[6]，他的元素值为7，而索引6对应的原始数组A中的元素为6+101=107，即107在排序后的位置是第7位，即result[6] = 107，排完后count[6]的值需要减1，count[6]变为6。
如果索引值继续为6，在经过上一次的排序后，count[6]的值变成了6，即107在排序后的位置是第6位，即result[5] = 107，排完后count[6]的值需要减1，count[6]变为5。
至于第六步操作，就是为了找到A中的当前元素在结果数组result中排第几位，也就达到了排序的目的。
06 进阶版代码实现
public int[] countSort3(int[] A) { // 找出数组A中的最大值、最小值 int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE; for (int num : A) { max = Math.max(max, num); min = Math.min(min, num); } // 初始化计数数组count // 长度为最大值减最小值加1 int[] count = new int[max-min+1]; // 对计数数组各元素赋值 for (int num : A) { // A中的元素要减去最小值，再作为新索引 count[num-min]++; } // 计数数组变形，新元素的值是前面元素累加之和的值 for (int i=1; i<count.length; i++) { count[i] += count[i-1]; } // 创建结果数组 int[] result = new int[A.length]; // 遍历A中的元素，填充到结果数组中去 for (int j=0; j<A.length; j++) { result[count[A[j]-min]-1] = A[j]; count[A[j]-min]--; } return result; }
07 进阶版的延伸之一
如果我们想要原始数组中的相同元素按照本来的顺序的排列，那该怎么处理呢？
依旧以上一个数组{101,109,107,103,108,102,103,110,107,103}为例，其中有两个107，我们要实现第二个107在排序后依旧排在第一个107的后面，可以在第六步的时候，做下变动就可以实现，用倒序的方式遍历原始数组，即从后往前遍历A数组。
从后往前遍历，第一次遇到107（A[8]）时，107-101 = 6，count[6] = 7，即第二个107要排在第7位，即result[6] = 107，排序后count[6] = 6。
继续往前，第二次遇到107（A[2]）时，107-101 = 6，count[6] = 6，即第一个107要排在第6位，即result[5] = 107，排序后count[6] = 5。
public int[] countSort4(int[] A) { // 找出数组A中的最大值、最小值 int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE; for (int num : A) { max = Math.max(max, num); min = Math.min(min, num); } // 初始化计数数组count // 长度为最大值减最小值加1 int[] count = new int[max-min+1]; // 对计数数组各元素赋值 for (int num : A) { // A中的元素要减去最小值，再作为新索引 count[num-min]++; } // 计数数组变形，新元素的值是前面元素累加之和的值 for (int i=1; i<count.length; i++) { count[i] += count[i-1]; } // 创建结果数组 int[] result = new int[A.length]; // 遍历A中的元素，填充到结果数组中去，从后往前遍历 for (int j=A.length-1; j>=0; j--) { result[count[A[j]-min]-1] = A[j]; count[A[j]-min]--; } return result; }
08 进阶版的延伸之二
既然从后往前遍历原始数组的元素可以保证其原始排序，那么从前往后可不可以达到相同的效果？
答案时可以的。
第一步：找出数组中的最大值max、最小值min。
第二步：创建一个新数组count，其长度是max-min加1再加1，其元素默认值都为0。
第三步：遍历原数组中的元素，以原数组中的元素作为count数组的索引，以原数组中的元素出现次数作为count数组的元素值。
第四步：对count数组变形，新元素的值是前面元素累加之和的值，即count[i+1] = count[i+1] + count[i];。
第五步：创建结果数组result，长度和原始数组一样。
第六步：从前往后遍历原始数组中的元素，当前元素A[j]减去最小值min，作为索引，在计数数组中找到对应的元素值count[A[j]-min]，就是A[j]在结果数组result中的位置，做完上述这些操作，count[A[j]-min]自增加1。
依旧以上一个数组{101,109,107,103,108,102,103,110,107,103}为例，其中有两个107，我们要实现第一个107在排序后依旧排在第二个107的前面。
此时计数数组count为{0, 1, 2, 5, 5, 5, 5, 7, 8, 9, 10}，从前往后遍历原始数组A中的元素。
第一次遇到107（A[2]）时，107-101 = 6，count[6] = 5，即第一个107在结果数组中的索引为5，即result[5] = 107，排序后count[6] = 6。
第二次遇到107（A[8]）时，107-101 = 6，count[6] = 6，即第二个107在结果数组中的索引为6，即result[6] = 107，排序后count[6] = 7。
public int[] countSort5(int[] A) { // 找出数组A中的最大值、最小值 int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE; for (int num : A) { max = Math.max(max, num); min = Math.min(min, num); } // 初始化计数数组count // 长度为最大值减最小值加1，再加1 int[] count = new int[(max-min+1)+1]; // 对计数数组各元素赋值，count[0]永远为0 for (int num : A) { // A中的元素要减去最小值再加上1，再作为新索引 count[num-min+1]++; } // 计数数组变形，新元素的值是前面元素累加之和的值 for (int i=1; i<count.length; i++) { count[i] += count[i-1]; } // 创建结果数组 int[] result = new int[A.length]; // 遍历A中的元素，填充到结果数组中去，从前往后遍历 for (int j=0; j<A.length; j++) { // 如果后面遇到相同的元素，在前面元素的基础上往后排 // 如此就保证了原始数组中相同元素的原始排序 result[count[A[j]-min]] = A[j]; count[A[j]-min]++; } return result; }
09 小结
以上就是计数排序算法的全部内容了，虽然它可以将排序算法的时间复杂度降低到O(N)，但是有两个前提需要满足：一是需要排序的元素必须是整数，二是排序元素的取值要在一定范围内，并且比较集中。只有这两个条件都满足，才能最大程度发挥计数排序的优势。
原文 ：https://www.cnblogs.com/xiaochuan94/p/11198610.html