基数排序

 基数排序（桶排序）介绍：
1）基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucketsort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
2）基数排序法 是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
3）基数排序（Radix Sort）是桶排序的扩展
4）基数排序是1887年赫尔曼●何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。

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

package com.zx.ds.ds0810;

import java.util.Arrays;

public class RadixSort {

    public static void sort(int array[]){

        int bucket[][]=new int[10][array.length];
        int bucketElementCounts[]=new int[10];

        //逐步推演
        //按个位排序
        for(int i=0;i

package com.zx.ds.ds0810;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class RadixSort2 {

    public static void sort(int array[]) {

        //定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
        //说明
        //1. 二维数组包含10个一维数组
        //2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
        //3. 明确，基数排序是使用空间换时间的经典算法
        int bucket[][] = new int[10][array.length];

        //为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
        //可以这里理解
        //比如：bucketElementCounts[0] , 记录的就是  bucket[0] 桶的放入数据个数
        int bucketElementCounts[] = new int[10];

        //1. 得到数组中最大的数的位数
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        //得到最大数是几位数
        int maxLength = (max + "").length();

        for (int t = 0,n=1; t < maxLength; t++,n*=10) {
            //(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
            for (int i = 0; i < array.length; i++) {
                //取出每个元素的对应位的值
                int digitOfElement = array[i] /n % 10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = array[i];
                bucketElementCounts[digitOfElement]++;
            }

            //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
            int index = 0;
            //遍历每一桶，并将桶中是数据，放入到原数组
            for (int i = 0; i < bucketElementCounts.length; i++) {
                //如果桶中，有数据，我们才放入到原数组
                if (bucketElementCounts[i] != 0) {
                    //循环该桶即第k个桶(即第k个一维数组), 放入
                    for (int j = 0; j < bucketElementCounts[i]; j++) {
                        array[index] = bucket[i][j];
                        index++;
                    }
                }
                //第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
                bucketElementCounts[i] = 0;
            }

            //System.out.println(Arrays.toString(array));
        }
    }
    public static void main(String[] args) {

        int array[]={53,3,542,748,14,214};

//        sort(array);
//        System.out.println(Arrays.toString(array));
        //---1---
        //[542, 53, 3, 14, 214, 748]
        //---2---
        //[3, 14, 214, 542, 748, 53]
        //---3---
        //[3, 14, 53, 214, 542, 748]
        //[3, 14, 53, 214, 542, 748]

        sort(array);
        System.out.println(Arrays.toString(array));

        int big[] = new int[80000000];
        for (int i = 0; i < big.length; i++) {
            big[i] = (int) (Math.random() * 8000000);
        }
        int temp2[]=new int[big.length];

        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateToStr = simpleDateFormat.format(date);
        System.out.println("before sort: " + dateToStr);

        sort(big);

        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateToStr2 = simpleDateFormat2.format(date2);
        System.out.println("after sort: " + dateToStr2);
        //[3, 14, 53, 214, 542, 748]
        //before sort: 2020-08-10 14:45:33
        //after sort: 2020-08-10 14:45:33

        // 测试8000 0000数据时会报错 需要的内存太大
        // Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        //	at com.zx.ds.ds0810.RadixSort2.sort(RadixSort2.java:11)
        //	at com.zx.ds.ds0810.RadixSort2.main(RadixSort2.java:70)
    }
}

排序算法的比较

排序法	平均时间	最差情形	稳定度	额外空间	备注	80000随机数排序时间(s)
冒泡	O(n²)	O(n²)	稳定	O(1)	n小时较好	13
选择	O(n²)	O(n²)	不稳定	O(1)	n小时较好	4
插入	O(n²)	O(n²)	稳定	O(1)	大部分已排序时较好	2
希尔	O(nlogn)	O(n的s次方) 1	不稳定	O(1)	s是所选分组	1
快速	O(nlogn)	O(n²)	不稳定	O(nlogn)	n大时较好	不到1
归并	O(nlogn)	O(nlogn)	稳定	O(n)	n大时较好	不到1
基数	O(NXk)	O(NXk)	稳定	O(N+k)		不到1

注：

1）基数排序是对传统桶排序的扩展，速度很快.
2）基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError。
3）基数排序时稳定的。[注：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的：否则称为不稳定的
4）有负数的数组，我们不用基数排序来进行排序，如果要支持负数，参考：htps:/i-hamess com/zh-CN/q/e98fa9 

常用排序算法的总结和比较

相关术语解释：
1）稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
2）不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面：.
3）内排序：所有排序操作都在内存中完成；
4）外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
5）时间复杂度：一个算法执行所耗费的时间。
6）空间复杂度：运行完一个程序所需内存的大小。
7）n：数据规模
8）k:“桶”的个数
9）In-place：不 占用额外内存
10）Out-place：占用额外内存