计数排序

思路

1.遍历原始数组 arr 找到最大值和最小值，确定计数数组 countArr 的范围
2.遍历 arr 并计数于 countArr
3.对 countArr 做调整，每个数等于前面的数之和
4.反向遍历 arr，对应 countArr 中的数减 1，就是 sortedArr 中的位置

代码

public class CountSort{
    public static int[] countSort(int[] arr) {
       int min = arr[0];
       int max = arr[0];
       for(int i = 1; i < arr.length; i++){
           if(arr[i] < min)
               min = arr[i];
           if(arr[i] > max)
               max = arr[i];
       }

       int[] countArr = new int[arr.length];
       for(int i = 0; i < arr.length; i++){
           countArr[arr[i] - min] ++;
       }

       int sum = 0;
       for(int i = 0; i < countArr.length;i ++){
           sum += countArr[i];
           countArr[i] = sum;
       }

       int[] sortedArr = new int[arr.length];
       for(int i = arr.length - 1; i >= 0; i--){
           sortedArr[countArr[arr[i] - min] - 1] = arr[i];
           countArr[arr[i] - min] --;
       }
       return sortedArr;
    }


    public static void main(String[] args){
        int[] array = new int[]{5,5,8,6,6,3,9,2,1,4,7,1,2,9};
        int[] sortedArr = countSort(array);
        System.out.println(Arrays.toString(sortedArr));
    }
}

复杂度分析

时间复杂度

第1、2、4步 O(n)，第3步 O(k)，共 O(n + k)
最好最坏需要一样的步数

空间复杂度

不考虑返回数组的长度
O(k)

稳定性分析

经过第三步优化，稳定

优势

特定情况下比快速排序还快，而且还是稳定的

适用场景

小范围内有重复的整数