基数排序算法及其Java实现详解

由 Java Q&A Hub 使用 GPT-4o-mini 回答

问题：

基数排序

回答：

基数排序（Radix Sort）是一种非比较型整数排序算法，它通过将整数分解为多个数字位来进行排序。基数排序的基本思想是将待排序的数值按位进行排序，从最低位到最高位（或从最高位到最低位），通常使用稳定的排序算法（如计数排序）作为子排序。

基数排序的步骤

  1. 确定最大数的位数：首先找出待排序数组中最大数的位数。
  2. 按位排序：从最低位开始，对每一位进行排序，使用稳定的排序算法（如计数排序）。
  3. 重复步骤2：对每一位进行排序，直到最高位。

基数排序的时间复杂度

基数排序的时间复杂度为 (O(d \cdot (n + k)))，其中：

  • (n) 是待排序的元素数量。
  • (d) 是数字的位数。
  • (k) 是基数（即每位可能的取值范围，通常是10）。

基数排序的空间复杂度

基数排序的空间复杂度为 (O(n + k))，主要用于存储计数数组和输出数组。

Java 实现基数排序

下面是一个基数排序的 Java 实现示例：

import java.util.Arrays;

public class RadixSort {

    // 主函数
    public static void main(String[] args) {
        int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
        System.out.println("原始数组: " + Arrays.toString(arr));
        radixSort(arr);
        System.out.println("排序后数组: " + Arrays.toString(arr));
    }

    // 基数排序函数
    public static void radixSort(int[] arr) {
        // 找到最大值
        int max = getMax(arr);
        // 对每一位进行排序
        for (int exp = 1; max / exp > 0; exp *= 10) {
            countingSort(arr, exp);
        }
    }

    // 计数排序函数，基于特定位进行排序
    private static void countingSort(int[] arr, int exp) {
        int n = arr.length;
        int[] output = new int[n]; // 输出数组
        int[] count = new int[10]; // 计数数组，基数为10

        // 初始化计数数组
        Arrays.fill(count, 0);

        // 统计每个数字的出现次数
        for (int i = 0; i < n; i++) {
            count[(arr[i] / exp) % 10]++;
        }

        // 计算累计计数
        for (int i = 1; i < 10; i++) {
            count[i] += count[i - 1];
        }

        // 构建输出数组
        for (int i = n - 1; i >= 0; i--) {
            output[count[(arr[i] / exp) % 10] - 1] = arr[i];
            count[(arr[i] / exp) % 10]--;
        }

        // 将排序后的数组复制回原数组
        for (int i = 0; i < n; i++) {
            arr[i] = output[i];
        }
    }

    // 获取数组中的最大值
    private static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

代码分析

  1. 主函数：定义了一个整数数组并调用 radixSort 方法进行排序。
  2. radixSort 方法：首先找到数组中的最大值，然后对每一位进行计数排序。
  3. countingSort 方法：实现了基于特定位的计数排序。它使用一个计数数组来统计每个数字在当前位上的出现次数，并根据这些计数构建输出数组。
  4. getMax 方法：用于获取数组中的最大值，以确定排序的位数。

总结

基数排序是一种高效的排序算法，特别适合于处理大量的整数数据。它的时间复杂度在某些情况下优于比较排序算法（如快速排序和归并排序），但需要额外的空间来存储计数数组和输出数组。

Related