Orden de base
Introducción
1) Radix sort (radixsort) pertenece a " distribution sort" (distributionsort) , también conocido como ** "bucket sort **" (bucket sort) o binsort, como su nombre lo indica, se ordena por el valor de cada bit de el valor clave Los elementos de se asignan a algunos "cubos" para lograr el efecto de clasificación.
2) El método de clasificación por base es una clasificación estable , y el método de clasificación por base es un método de clasificación eficiente y estable.
3) La clasificación por base ( RadiXSort) es una clasificación de cubos. Extensión
4) La clasificación de números cardinales fue inventada en 1887 por Hermann Holly. Se implementa así: el entero se corta en diferentes números de acuerdo con los dígitos y luego se compara de acuerdo con cada dígito.
Diagrama
Ordenar el pensamiento
Unifique todos los valores que se van a comparar con la misma longitud de dígito y rellene ceros delante de los números con dígitos más cortos. Luego, comenzando desde el bit más bajo, ordene una vez en secuencia. De esta forma, desde el orden más bajo hasta el más alto, la secuencia se convierte en una secuencia ordenada.
comprensión
Es decir, contamos los números y los colocamos en la posición correspondiente. Por ejemplo, ponemos 3 en la columna 3 y 41 en la columna 1. ¿Y si el 3 es un solo dígito, y se agrega un cero al frente? Es 03, entonces la columna 3 es uno de nuestros cubos, 1 también es un cubo, 51 también está en el cubo 1 y 23 también está en el cubo 3.
En otras palabras, tenemos 10 cubos del 0 al 9 (no necesariamente exactamente 10 cubos)
Tema: El equipo de HKUST tiene las siguientes puntuaciones: 53,3,542,748,14,214. Utilice el método de ordenación por radix para ordenar las puntuaciones de estas personas de menor a mayor
paso
1. Saque el único dígito de cada elemento y luego coloque este número en el depósito correspondiente (un depósito es una matriz de un bit )
2. Saque los datos en secuencia según el orden del depósito (subíndice de matriz unidimensional) y vuelva a colocarlos en la matriz original.
3. La primera ronda de clasificación de la matriz
542 53 3 14 214 748
4. De acuerdo con la operación de ahora, haremos 542 53 3 14 214 748 nuevamente, pero esta vez iremos a diez dígitos para especificar nuestro depósito.
0 barriles 3
1 barril 14 214
4 barriles 542748
5 barriles de 53
Regresar a la matriz original
5. La segunda ronda de clasificación de resultados
3 14 214 542 748 53
6. En la tercera ronda, la misma razón es que sobre la base de la segunda ronda de clasificación, definimos nuestros cubos de acuerdo con los cien dígitos.
0 barril 3 14 53
2 barriles 214
5 barriles 542
7 barriles 748
El resultado del tercer tipo
3 14 53 214542748 es nuestro resultado final
Podemos ver que no hay paso recursivo ¿Cuántas veces se necesita? Depende del número de dígitos del número más grande de nuestra matriz. El número más grande de 748 en esta matriz es el dígito de las centenas, por lo que tiene 3 dígitos. Si tiene 4 dígitos, 4 veces
Derivar el código
//基数排序方法
public static void radixSort(int[] arr){
//第一轮排序（针对每个元素的个位进行排序）
//定义一个二维数组，表示10个桶，每个桶就是一个一位数组
//说明
//1.二维数组包含10个一位数组，但是一位数组要多大？
//2.为了防止再放入数字的时候，数据溢出，则我们每个一位数组(桶)大小定位arr.length
//基数排序也就是空间换时间的算法
int[][] bucket = new int[10][arr.length];//这个桶要多大？
//我们怎么把数据从桶中取出来呢？我们桶中实际有多少个数据呢？
//为了记录，我们定义一个一维数组来记录各个桶中每次放入的个数
//bucketElementCounts[0]就是记录0桶中有几个数据
int[] bucketElementCounts = new int[10];
//第一轮
for(int j = 0;j < arr.length;j++){
//取出个位数字
int digitOfElement = arr[j] %10;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//重新放回原数组
int index = 0;
//遍历每一个桶，并将桶中的数据放入到原数组
for(int k = 0; k < bucketElementCounts.length;k++){
//如果桶中有数据
if(bucketElementCounts[k] != 0){
//循环该桶 即第k个桶，即第k个一维数组
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素，放回原数组
arr[index] = bucket[k][l];
index++;
}
//第一轮取出数据后，需要将每个bucketElementCounts[k] = 0
//为了我们第二轮第三轮处理的时候，没有数据
bucketElementCounts[k] = 0;
}
}
System.out.println("第一轮对个位的排序处理"+Arrays.toString(arr));
//第二轮处理
for(int j = 0;j < arr.length;j++){
//取出个位数字
int digitOfElement = arr[j] /10 %10;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//重新放回原数组
index = 0;
//遍历每一个桶，并将桶中的数据放入到原数组
for(int k = 0; k < bucketElementCounts.length;k++){
//如果桶中有数据
if(bucketElementCounts[k] != 0){
//循环该桶 即第k个桶，即第k个一维数组
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素，放回原数组
arr[index] = bucket[k][l];
index++;
}
bucketElementCounts[k] = 0;
}
}
System.out.println("第二轮对十位的排序处理"+Arrays.toString(arr));
//第三轮
for(int j = 0;j < arr.length;j++){
//取出个位数字
int digitOfElement = arr[j] /100;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//重新放回原数组
index = 0;
//遍历每一个桶，并将桶中的数据放入到原数组
for(int k = 0; k < bucketElementCounts.length;k++){
//如果桶中有数据
if(bucketElementCounts[k] != 0){
//循环该桶 即第k个桶，即第k个一维数组
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素，放回原数组
arr[index] = bucket[k][l];
index++;
}
bucketElementCounts[k] = 0;
}
}
System.out.println("第三轮对百位的排序处理"+Arrays.toString(arr));
}
Código final
import java.util.Arrays;
//基数排序
//@author 王庆华
//2021年1月14日13:39:02
public class RadioxSort {
public static void main(String[] args) {
int arr[] = {
53,3,542,748,14,214};
radixSort(arr);
}
//基数排序方法
public static void radixSort(int[] arr){
//1.得到数组中最大数的位数
int max = arr[0];//假设第一个数就是最大数
for(int i=1;i < arr.length;i++){
if(arr[i] > max){
max = arr[i];
}
}
//得到最大数是几位数
int maxLength = (max+"").length();//变成字符串
int[][] bucket = new int[10][arr.length];
int[] bucketElementCounts = new int[10];
//使用循环对代码处理
for(int i = 0, n = 1;i<maxLength;i++,n*=10){
//针对每个元素的对应的位数进行排序
for(int j = 0;j < arr.length;j++){
//取出个位数字
int digitOfElement = arr[j] /n %10;
//放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//重新放回原数组
int index = 0;
//遍历每一个桶，并将桶中的数据放入到原数组
for(int k = 0; k < bucketElementCounts.length;k++){
//如果桶中有数据
if(bucketElementCounts[k] != 0){
//循环该桶 即第k个桶，即第k个一维数组
for(int l = 0;l < bucketElementCounts[k];l++){
//取出元素，放回原数组
arr[index] = bucket[k][l];
index++;
}
//第一轮取出数据后，需要将每个bucketElementCounts[k] = 0
//为了我们第二轮第三轮处理的时候，没有数据
bucketElementCounts[k] = 0;
}
}
System.out.println("第"+(i+1)+"轮对个位的排序处理"+Arrays.toString(arr));
}
}
}