八大排序算法--基数排序

原理：

• 将整数按位数切割成不同的数字，然后按每个位数分别比较。
• 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。
• 然后从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
• 这里用到了一种可以压缩空间的方法，且时间复杂度并没有偏离得太厉害。那就是设计了两个辅助数组，一个是 output[]，一个是 bucket[]。output 用于临时存储待排序的数据，bucket 用于记录在某个桶中的最后一个元素的下标，然后再把原数组中的元素计算一下它应该属于哪个“桶”，并修改相应位置的 bucket 值。直到最大数的最高位也被添加到桶中，基数排序就结束了。

参考文章​​​​​链接：https://blog.csdn.net/lemon_tree12138/article/details/51695211

代码如下：

import java.util.Arrays;

public class RadixSort {

    public static void main(String[] args) {
        int[] arr = randomArray(11);
        radixSort(arr);    // 基数排序
        System.out.println(Arrays.toString(arr));
    }

    /*
     * 获取数组a中最大值
     * 参数说明：
     *     a -- 数组
     *     n -- 数组长度
     */
    private static int getMax(int[] a) {
        int max;
        max = a[0];
        for (int i = 1; i < a.length; i++)
            if (a[i] > max)
                max = a[i];

        return max;
    }

    /*
     * 对数组按照"某个位数"进行排序(桶排序)
     * 参数说明：
     *     a -- 数组
     *     exp -- 指数。对数组a按照该指数进行排序。
     * 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；
     *    (01) 当exp=1表示按照"个位"对数组a进行排序
     *    (02) 当exp=10表示按照"十位"对数组a进行排序
     *    (03) 当exp=100表示按照"百位"对数组a进行排序
     */
    private static void countSort(int[] a, int exp) {
        //int output[a.length];    // 存储"被排序数据"的临时数组
        int[] output = new int[a.length];    // 存储"被排序数据"的临时数组
        int[] buckets = new int[10];

        // 将数据出现的次数存储在buckets[]中
        for (int i = 0; i < a.length; i++)
            buckets[ (a[i]/exp)%10 ]++;

        // 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
        for (int i = 1; i < 10; i++)
            buckets[i] += buckets[i - 1];

        // 将数据存储到临时数组output[]中
        for (int i = a.length - 1; i >= 0; i--) {
            output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];
            buckets[ (a[i]/exp)%10 ]--;
        }

        // 将排序好的数据赋值给a[]
        for (int i = 0; i < a.length; i++)
            a[i] = output[i];

        output = null;
        buckets = null;
    }

    /*
     * 基数排序
     * 参数说明：
     *     a -- 数组
     */
    public static void radixSort(int[] a) {
        int exp;    // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
        int max = getMax(a);    // 数组a中的最大值
        // 从个位开始，对数组a按"指数"进行排序
        for (exp = 1; max/exp > 0; exp *= 10)
            countSort(a, exp);
    }

    public static int[] randomArray(int length) {
        int[] arr = new int[length];
        Random random = new Random();
        for(int i=0; i<length; i++) {
            arr[i] = random.nextInt(100);
        }
        //自动生成随机数组，先进行一次原始数据打印
        System.out.println(Arrays.toString(arr));
        return arr;
    }
}

代码执行结果如图所示：

复杂度：

• 时间复杂度：O()
• 空间复杂度：O(n)
• 稳定性：稳定  

如果遇到相等的值不进行交换，那这种排序方式是稳定的排序方式。

最后附上八大排序算法的时间、空间复杂度以及稳定性：