十大排序算法之十 - 基数排序

十大排序算法之十 - 基数排序

1.基数排序的介绍

• 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

• 算法描述

  • 取得数组中的最大数，并取得位数；
  • arr为原始数组，从最低位开始取每个位组成radix数组；
  • 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

2.Java实现基数排序并进行测试

2.1 Java实现基数排序

package com.lagou.radixSort;

/**
 * @author 云梦归遥
 * @date 2022/5/29 22:40
 * @description
 */
public class RadixSortMethod {
    // 排序
    public int[] sort(int[] array){
        if(array.length == 0)
            return null;
        //找到最大值的位数
        int maxBit = 1;
        int number = 10;
        for(int i = 0;i < array.length;i ++){
            if(array[i] >= number){
                number = 10; maxBit = 1;
                int temp = array[i];
                while (temp / 10 > 0){
                    number = number * 10;
                    maxBit++;
                    temp /= 10;
                }
            }
        }
        System.out.println("最大值的位数：" + maxBit);
        return sort(maxBit,array);
    }

    // 实现排序
    private int[] sort(int maxBit,int[] array){
        // 二维数组储存每次得到的数
        // 创建二维数组来储存每次得到的数
        int[][] arrays = new int[10][array.length]; // 二维数组里创建十个数组，长度为要排序数组长度
        int[] numberes; // 记录二维数组中每个数组内的个数
        int bit; // 每次取余得到的数
        int index; // 排序数组的索引
        int flag = 0;  // 如果是排个位
        int num = 1;
        while(flag < maxBit){
            if(flag == 0)
                num = 1;
            else
                num = num * 10;
            numberes = new int[10];
            for(int i = 0;i < array.length;i ++){
                // 拿到每个数的位
                bit = (array[i] / num) % 10; // 取余
                // 添加到二维数组中
                arrays[bit][numberes[bit]] = array[i];
                // 个数加1
                numberes[bit] ++;
            }
            // 得到的新数组
            index = 0;
            for(int i = 0;i < 10;i ++){
                for(int j = 0;j < numberes[i];j ++){
                    array[index] = arrays[i][j];
                    index ++;
                }
            }
            System.out.print("第"+ flag + "次排序：");
            for(int i = 0;i < array.length;i ++){
                System.out.print(array[i] + "  ");
            }
            System.out.println();
            flag ++;
        }
        return array;
    }
}

2.2 进行测试

package com.lagou.radixSort.test;

import com.lagou.radixSort.RadixSortMethod;

import java.util.Arrays;

/**
 * @author 云梦归遥
 * @date 2022/5/29 22:41
 * @description
 */
public class RadixSortMethodTest {
    public static void main(String[] args) {
        RadixSortMethod radixSortMethod = new RadixSortMethod();
        //int[] array = new int[]{1439,99,4,0,123,567,890,1374};
        int[] array = new int[]{1439,99,4,0,88,77,55,22};
        System.out.println("【基数排序】原数组：" + Arrays.toString(array));
        int[] sort = radixSortMethod.sort(array);
        System.out.println("【基数排序】新数组：" + Arrays.toString(sort));
    }
}

3.总结

• 基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。

• 基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右