【算法】基数排序的原理与Java实现

 一.基数排序原理

基数排序（Radix Sort）是一种非比较性的排序算法，它根据元素的位数逐位进行排序。基数排序的核心思想是将待排序的元素按照低位到高位的顺序进行排序，每一位都使用稳定的排序算法（通常是计数排序或桶排序）。通过多次按位排序，最终可以得到有序的结果。

基数排序的具体步骤如下：

1. 根据待排序元素的最大位数确定排序的轮数：首先找到待排序数组中的最大元素，计算出最大元素的位数，将位数作为排序的轮数。
2. 对每一位进行排序：从低位到高位，依次对每一位进行排序。
   • 使用稳定的排序算法（如计数排序或桶排序）对当前位进行排序。
   • 按照当前位的排序结果重新排列待排序数组。
3. 重复步骤2，直到完成所有位的排序。

二.使用Java实现基数排序

public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
        
        System.out.println("Before sorting:");
        printArray(arr);
        
        radixSort(arr);
        
        System.out.println("After sorting:");
        printArray(arr);
    }
    
    public static void radixSort(int[] arr) {
        // 找到数组中的最大值
        int max = getMax(arr);
        
        // 对每一位进行排序
        for (int exp = 1; max / exp > 0; exp *= 10) {
            countingSort(arr, exp);
        }
    }
    
    public static void countingSort(int[] arr, int exp) {
        int n = arr.length;
        int[] output = new int[n];
        int[] count = new int[10];
        
        // 统计当前位的元素个数
        for (int i = 0; i < n; i++) {
            int digit = (arr[i] / exp) % 10;
            count[digit]++;
        }
        
        // 将统计结果转换为位置索引
        for (int i = 1; i < 10; i++) {
            count[i] += count[i - 1];
        }
        
        // 构建排序后的数组
        for (int i = n - 1; i >= 0; i--) {
            int digit = (arr[i] / exp) % 10;
            output[count[digit] - 1] = arr[i];
            count[digit]--;
        }
        
        // 将排序后的数组复制回原数组
        System.arraycopy(output, 0, arr, 0, n);
    }
    
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int num : arr) {
            if (num > max) {
                max = num;
            }
        }
        return max;
    }
    
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

以上代码使用基数排序算法对一个整数数组进行排序。radixSort方法实现了基数排序的逻辑，通过多次按位排序，将待排序的数组按照低位到高位的顺序进行排序。在每一位的排序过程中，使用计数排序算法对当前位进行排序。

运行以上代码，将输出如下结果：

Before sorting:
170 45 75 90 802 24 2 66 
After sorting:
2 24 45 66 75 90 170 802

基数排序算法的时间复杂度为O(d * (n + k))，其中d是最大元素的位数，n是数组的长度，k是基数的取值范围。基数排序是一种稳定的排序算法，适用于非负整数或具有固定位数的其他类型的排序。