基数排序

06 基数排序

测试链接 : 【模板】排序 - 洛谷

思路:

• 指定一个进制,按照(非负整数)数组中最大值的位数进行基数排序

• 基数排序内部按照最大值的位数, 从最低位开始进行排序

  • 依次记录该位上数组中每个数的个数,放入cnt数组中

  • 根据cnt数组, 计算出前缀数组

  • 前缀数组中该数(arr[i]) 的值-1 就是要放在help数组中的位置

    • 要从后往前放置, 保证数据的稳定性

• 将辅助数组中的值刷回原数组

• 将原数组-min,转为初始数值

代码:

• import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.io.StreamTokenizer;
  import java.util.Arrays;
  ​
  public class Main {
  ​
      // 可以设置进制，不一定10进制，随你设置
      public static int BASE = 10;// 进制
  ​
      public static int MAXN = 100001;
  ​
      public static int[] arr = new int[MAXN];
  ​
      public static int[] help = new int[MAXN];
  ​
      public static int[] cnts = new int[BASE];//如果为10进制,则保存下标0-9,标志数组中每位0-9各有多少个
  ​
      public static int n;// 数组中数字的总个数
  ​
      public static void main(String[] args) throws IOException {
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// new
          StreamTokenizer in = new StreamTokenizer(br);
          PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));// new OutputStreamWriter(System.out)
          in.nextToken();
          n = (int) in.nval;
          for (int i = 0; i < n; i++) {// 依次读入数组中的数
              in.nextToken();
              arr[i] = (int) in.nval;
          }
          sort();
          for (int i = 0; i < n - 1; i++) {
              out.print(arr[i] + " ");
          }
          out.println(arr[n - 1]);// 拼凑格式
          out.flush();
          out.close();
          br.close();
      }
  ​
      public static void sort() {// 如果会溢出，那么要改用long类型数组来排序
          // 1. 找到数组中的最小值
          int min = arr[0];// 假设最小数是第一个,可以少循环一次
          for (int i = 1; i < n; i++) {
              min = Math.min(min, arr[i]);
          }
          
          int max = 0;// 根据最大值在BASE进制下的位数，决定基数排序做多少轮
          
          // 2. 将整个数组变为非负数组,并记录最大值
          for (int i = 0; i < n; i++) {// 数组中的每个数字，减去数组中的最小值，就把arr转成了非负数组
              arr[i] -= min;
              // 记录数组中的最大值
              max = Math.max(max, arr[i]);
          }
          
          // 3. 根据最大值的位数进行基数排序
          radixSort(bits(max));
          
          // 4. 数组中所有数都减去了最小值，所以最后不要忘了还原
          for (int i = 0; i < n; i++) {
              arr[i] += min;
          }
      }
  ​
      // 返回number在BASE进制下有几位,即要做排序几轮
      public static int bits(int number) {
          int ans = 0;
          while (number > 0) {
              ans++;
              number /= BASE;
          }
          return ans;
      }
  ​
      // 基数排序核心代码
      // arr内要保证没有负数
      // m是arr中最大值在BASE进制下有几位
      public static void radixSort(int bits) {
          // 每次取得每一位的值,按照每一位进行排序
          // 理解的时候可以假设BASE = 10
          for (int offset = 1; bits > 0; offset *= BASE, bits--) {// !!!每一位都要进行比较,根据剩余比较位数是否到0来确定循环次数
              Arrays.fill(cnts, 0);// 统计数组
              
              // 1. 提取每一位数字,放入统计数组
              for (int i = 0; i < n; i++) {
                  // 数字提取某一位的技巧
                  cnts[(arr[i] / offset) % BASE]++;
              }
              
              // 2. 计算前缀数组
              for (int i = 1; i < BASE; i++) {
                  cnts[i] = cnts[i] + cnts[i - 1];
              }
              
              // 3. 将某位的数!!!从后往前!!!(保证稳定性)放入辅助数组中该数个数减一的地方
              for (int i = n - 1; i >= 0; i--) {
                  // 前缀数量分区的技巧
                  // 数字提取某一位的技巧
                  help[--cnts[(arr[i] / offset) % BASE]] = arr[i];
              }
              
              // (arr[i] / offset) % BASE : 提取每一位数字
              // cnts[(arr[i] / offset) % BASE] : 找到统计数组中统计该数个数的位置
              // help[--cnts[(arr[i] / offset) % BASE]] : 将该数放到辅助数组中下标为个数减一的位置(即小于等于该数的最后一个位置,从而保证稳定性)
              
              // 4. 将统计数组中的值刷回原数组
              for (int i = 0; i < n; i++) {
                  arr[i] = help[i];
              }
              
          }
          
      }
  ​
  }