基数排序算法（基于Java实现）

title: 基数排序算法（基于Java实现）
tags: 基数算法

基数排序算法原理及代码实现：

一、基数排序算法的原理

基数排序属于“分配式排序”，又称“桶子法”。顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，最终达到排序的作用。

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

第一轮排序的时候，是将每个元素的个位数取出，然后看这个数应该放在哪个对应的桶中，排完序之后再按照桶的顺序依次取出；

第二轮排序的时候，是将每个元素的十位取出，然后后看这个数应该放入哪个对应的桶中，排完序后再按照桶的顺序依次取出；

第三轮排序跟前两次排序的情况是相同的，只不过在第三轮排序时是将每个元素的百位取出，其余的都一样。

看到这里，我们可以发现基数排序就是这样从最低为开始，依次进行一次排序，直到最低位排序一直到最高位排序完成以后，才能实现整个基数排序的排序过程。从整个实现的流程上来看，我们可以知道一点，就是排序的次数完全取决于需要排序数组中最大数的位数。

二、基数排序代码实现过程

package TestSort;

import java.util.Arrays;

public class Test {
    public static void radixSort(int[] arr){
      //寻找需要排列数组中的最大数
        int max = arr[0];
        for(int i = 1; i < arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
			//定义一个二维数组，表示有10个桶，即数值0-9的10个桶
      //为了防止在放入数的时候出现数据溢出，则设置每一个桶的大小为需要排列数组的长度，即arr.length
        int[][] bucket = new int[10][arr.length];
      //定义一个一维数组，记录每个桶的每次放入的数据个数
      //比如bucketOfElementCounts[0]，记录的就是bucket[0]桶中放入数据的个数
        int[] bucketOfElementCounts = new int[10];
        int maxLength = (max + "").length();

        for(int i = 0, n = 1; i < maxLength; i++, n *= 10){
						//针对每个元素的对应位进行排序处理，第一次是个位，第二次是十位，第三次是百位。。。
            for(int j = 0; j < arr.length; j++){
              //取出每一个元素的对应位的值
                int count = arr[j] / n % 10;
              //放入到对应的桶中
                bucket[count][bucketOfElementCounts[count]] = arr[j];
                bucketOfElementCounts[count]++;
            }
						//遍历一遍桶中的数据，按照这个桶的顺序，依次取出数据，放入原来的数组
            int index = 0;
            for(int k = 0; k < bucketOfElementCounts.length; k++){
              //如果桶中有数据，才将该桶的数据放入原数组
                if(bucketOfElementCounts[k] != 0){
										//循环该桶，将该桶中的数据依次放入到原数组中
                    for(int l = 0; l < bucketOfElementCounts[k]; l++){
                      //取出元素放入到arr
                        arr[index++] = bucket[k][l];
                    }
                }
              //在第i+1轮处理后，需要将每个bucketOfElementCounts[k] = 0，这一步很关键。
                bucketOfElementCounts[k] = 0;
            }
            System.out.println("第"+(i+1)+"轮，对各位的排序处理，arr="+ Arrays.toString(arr));
        }

    }

    public static void main(String[] args){
        int[] arr = {53, 3, 542, 748, 14, 214};
        radixSort(arr);
    }
}

输出结果：

第1轮，对各位的排序处理，arr=[542, 53, 3, 14, 214, 748]
第2轮，对各位的排序处理，arr=[3, 14, 214, 542, 748, 53]
第3轮，对各位的排序处理，arr=[3, 14, 53, 214, 542, 748]

三、基数排序算法的性能分析

基数排序是对传统桶排序的的一个扩展，速度很快。它是一种非常经典的以时间来换取空间的算法，占用内存较大。当对海量数据排序时，容易造成OutOfMemeoryError。它的时间复杂度O(n*k)，这个k值主要是看排序数组的数据的位数，因为数据的位数决定了基数排序的次数k。

基数排序是稳定的，它的空间复杂度为O(n+k)。