非比较类排序算法----java版(基数排序，计数排序，桶排序)

计数排序

思想

作为非比较类排序算法。计数排序必须要求输入的数据必须是有确定范围的整数。要求知道数组的范围的目的是创建一个长度为这个范围的数组，数组的内容保存的是这个对应下标数字出现的位置。
主要过程如下：
1.找到待排序序列最小和最大的元素。开辟一个新数组A长度就为max-min
2.统计数组中每个值为i的元素出现的次数，存入A的第i项。
3.累加完之后反向填充到目标数组中：把每个元素i(下标)放在新数组第i项，每放一个元素就将A第i个元素减一

代码

public class CountingSort {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arrs = new int[10000];
        for (int i = 0; i < 10000; i++) {
            arrs[i] = random.nextInt(10000);
        }
        countingSort(arrs);
        System.out.println(Arrays.toString(arrs));
    }
    public static void countingSort(int[] arrs){
        int max = arrs[0];
        for (int i = 0; i < arrs.length; i++) {
            if (max < arrs[i]){
                int temp = max;
                max = arrs[i];
                arrs[i] = temp;
            }
        }
        int[] res = new int[max + 1];
        for (int i = 0; i < arrs.length; i++) {
            res[arrs[i]]++;
        }
        int k = 0;
        for (int i = 0; i < res.length; i++) {
            for (int j = 0; j < res[i]; j++) {
                arrs[k++] = i;
            }
        }
    }
}

时间和空间复杂度

时间和空间复杂度都为$O(n+k)$，稳定的排序算法

桶排序

思想

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）

代码

public static void bucketSort(int[] arr){

        int max = arr[0];
        int min = arr[0];
        for(int i = 0; i < arr.length; i++){
            max = Math.max(max, arr[i]);
            min = Math.min(min, arr[i]);
        }

        //桶数
        int bucketNum = (max - min) / arr.length + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
        for(int i = 0; i < bucketNum; i++){
            bucketArr.add(new ArrayList<Integer>());
        }

        //将每个元素放入桶
        for(int i = 0; i < arr.length; i++){
            int num = (arr[i] - min) / (arr.length);
            bucketArr.get(num).add(arr[i]);
        }

        //对每个桶进行排序
        for(int i = 0; i < bucketArr.size(); i++){
            Collections.sort(bucketArr.get(i));
        }
        System.out.println(bucketArr.toString());

    }

时间和空间复杂度

时间复杂度最差$O(n^2)$，最好$O(n)$，平均$O(n+k)$；空间复杂度$O(n+k)$。稳定的排序算法。

基数排序

思想

基数排序思想是将整数按位数切分不同的数字，然后从最低位开始和其他数字的同位上的数字比较并排序；然后比较再高一位上的所有数字，排序。。。直到排序完成。

代码

public class RadixSort {
    public static void main(String[] args) {
        int[] arrays = {213,54,575,8,345,2235,4365,767,6,43,43,423342,
                34,35,454665,56,786887,54,34,3643,3,34,2353,64,35,86,476};
        radixSort(arrays);
        System.out.print(Arrays.toString(arrays)+"paixu");
    }
    
    public static void radixSort(int[] arrays){
        int maxvalue = arrays[0];
        for (int value : arrays){
            if (value > maxvalue)
                maxvalue = value;
        }
        int length = 0;
        for (int i = maxvalue; i != 0; i /= 10) {
            length++;
        }

        int mod = 10;
        int dev = 1;
        System.out.println("len="+length);

        for (int i = 0; i < length; i++, dev *= 10,mod *= 10) {
            int[][] counter = new int[10][0];//长度为10，因为区域操作结果区间只有10大小
            for (int j = 0; j < arrays.length; j++) {
                int bucket = (arrays[j] % mod) / dev;
                counter[bucket] = arrayAppend(counter[bucket],arrays[j]);//放到length个桶里
            }

            int pos = 0;
            for (int[] bucket : counter){//桶里的数据放回arrays
                for (int value : bucket){
                    arrays[pos++] = value;
                }
            }
        }
    }
    public static int[] arrayAppend(int[] arr,int value){//扩容
        arr = Arrays.copyOf(arr,arr.length + 1);
        arr[arr.length -1] = value;
        return arr;
    }
}

时间和空间复杂度

时间复杂度$O(n\ast k)$，空间复杂度$O(n+k)$，稳定的排序算法。