排序算法java实现——基数排序

一、基本思路

（1）基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用
（2）基数排序属于稳定性的排序
（3）基数排序是桶排序的扩展
（4）基数排序是1887年赫尔曼·何乐礼发明的，它是将整数按位数切割成不同的数字，然后按每个位数分别比较。

基本思路： 基数排序是将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

简单来说： 就是将序列中的每个数按照位数（个、十、百、千、万…）划分，再依次比较每个数的个位、十位、百位…，得到一个有序数列。

举例：
有一序列为：53, 3, 542, 748, 14, 214要求按升序排列
首先要创建10个桶来辅助排序：
（1）先将个位取出进行排序（序列为：53, 3, 542, 748, 14, 214）

0	1	2	3	4	5	6	7	8	9
			542	53 3	14 214			748

（2）再将十位取出来排序（序列为：542，53，3，14，214，748）

0	1	2	3	4	5	6	7	8	9
3	14 214			542 748	53

（3）再将百位取出来进行排序（序列为：3，14，214，542，748，53）

0	1	2	3	4	5	6	7	8	9
3 14 53		214			542		748

这样就得到了一个有序序列：3，14，53，214，542，748

二、算法分析

时间： 设待排序列为n个d位数，基数的取值范围为[0,k]，那么一趟排序中，需要遍历n个数并且放入k个桶中，耗时O(n*k)，一共d位数，每一位都要进行一趟比较，所以基数排序的时间复杂度为O(d(n+k))。
空间： 可以看到，基数排序时，我们需要利用桶来辅助排序，这就需要额外的开辟k个空间，每个空间大小为n，所以空间复杂度为：O(kn)

算法	平均时间	最好情形	最差情形	稳定度	空间复杂度	备注
基数排序	O(d(n*k))	O(d(n*k)	O(d(n*k)	稳定	O(kn)	n为个数,d为位数，k为基数的取值范围

三、代码实现

import java.util.Arrays;

/**
 * @author dankejun
 * @create 2020-04-29 16:32
 */
public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        radixSort(arr);
    }

    public static void radixSort(int[] arr) {
        //得到最大数的位数
        int max = arr[0];
        //求最大数
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //求最大值的位数，也就是需要排序的趟数
        int maxLength = (max + "").length();

        int[][] bucket = new int[10][arr.length];//桶
        int[] bucketElementCounts = new int[10];//存放各个桶中的元素个数

        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {//按位数进行每一趟排序
            for (int j = 0; j < arr.length; j++) {//将各位上的数放入桶中
                int digitOfElement = arr[j] / n % 10;//分离基数
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            }
            int index = 0;
            for (int k = 0; k < bucketElementCounts.length; k++) {//取出每一趟排序后的新序列
                if (bucketElementCounts[k] != 0) {
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        arr[index++] = bucket[k][l];
                    }
                }
                bucketElementCounts[k] = 0;//初始化桶中元素个数，为下一趟排序准备
            }
            System.out.printf("第%d轮：%s\n",i+1,Arrays.toString(arr));
        }
    }
}

测试序列： int arr[] = {53, 3, 542, 748, 14, 214};
测试结果：