| La ordenación por cardinalidad es un algoritmo de ordenación de enteros no comparativo. Su principio es cortar enteros en diferentes números según los dígitos y luego compararlos según cada dígito. Dado que los números enteros también pueden expresar cadenas (como nombres o fechas) y números de punto flotante en formatos específicos, la ordenación por base no se limita a los números enteros. |
1. Ordenación por cardinalidad vs. ordenación por conteo vs. ordenación por depósito
Hay dos métodos para ordenar por base:
Estos tres algoritmos de clasificación utilizan el concepto de depósitos, pero existen diferencias obvias en el uso de depósitos:
- Clasificación de cardinalidad: asigne cubos de acuerdo con cada dígito del valor de la clave;
- Clasificación por recuento: cada depósito solo almacena un único valor de clave;
- Clasificación de cubos: cada cubeta almacena un cierto rango de valores;
2. Demostración de animación de clasificación de cardinalidad LSD
Código:
JavaScript
Ejemplo
// LSD Radix Sort
var contador = [];
función radixSort (arr, maxDigit) {
var mod = 10;
var dev = 1;
for (var i = 0; i <maxDigit; i ++, dev * = 10, mod * = 10) {
for (var j = 0; j <longitud de arr.; j ++) {
var bucket = parseInt ((arr [j] % mod) / dev);
if (contador [cubo] == nulo) {
contador [cubo] = [];
}
contador [cubo] .push (arr [j]);
}
var pos = 0;
for (var j = 0; j <counter.length; j ++) {
var value = null;
if (contador [j]! = nulo) {
}
mientras ((valor = contador [j] .shift ())! = nulo) {
arr [pos ++] = valor;
}
}
}
return arr;
}
Java
Ejemplo
/ **
* Clasificación por radix
* También puede consultar el caso de números negativos: https://code.i-harness.com/zh-CN/q/e98fa9
* /
public class RadixSort implementa IArraySort {
@Override
public int [ ] sort (int [] sourceArray) throws Exception {
// Copiar arr sin cambiar el contenido del parámetro
int [] arr = Arrays.copyOf (sourceArray, sourceArray.length);
int maxDigit = getMaxDigit (arr);
return radixSort (arr, maxDigit );
}
/ **
* Obtiene el dígito más alto
* /
private int getMaxDigit (int [] arr) {
int maxValue = getMaxValue (arr);
return getNumLenght (maxValue);
}
private int getMaxValue (int [] arr) {
int maxValue = arr [0];
for (valor int: arr) {
if (maxValue <valor) {
maxValue = valor;
}
}
return maxValue;
}
protected int getNumLenght (long num) {
if (num == 0) {
return 1;
}
int longitud = 0;
para (temperatura larga = num; temperatura! = 0; temperatura / = 10) {
longitud ++;
}
longitud de retorno;
}
privado int [] radixSort (int [] arr, int maxDigit) {
int mod = 10;
int dev = 1;
para (int i = 0; i <maxDigit; i ++, dev * = 10, mod * = 10) {
// Considere el caso de números negativos, aquí el doble del número de colas, donde [0-9] corresponde a números negativos y [10-19] corresponde a números positivos (cubo + 10)
int [] [] contador = nuevo int [mod * 2] [0];
for (int j = 0; j <longitud de arr; j ++) {
int bucket = ((arr [j]% mod) / dev) + mod;
contador [bucket] = arrayAppend ( contador [depósito], arr [j]);
}
int pos = 0;
for (int [] depósito: contador) {
for (int valor: depósito) {
arr [pos ++] = valor;
}
}
}
return arr;
}
* @param arr
* @param value
/ **
* Expandir y guardar datos automáticamente
*
* /
private int [] arrayAppend (int [] arr, int valor) {
arr = Arrays.copyOf (arr, arr.length + 1);
arr [arr.length - 1] = valor;
return arr;
}
}
PHP
Ejemplo
function radixSort ($ arr, $ maxDigit = null)
{
if ($ maxDigit === null) {
$ maxDigit = max ($ arr);
}
$ contador = [];
for ($ i = 0; $ i <$ maxDigit; $ i ++) {
for ($ j = 0; $ j <count ($ arr); $ j ++) {
preg_match_all ('/ \ d /', (cadena) $ arr [$ j], $ coincidencias);
$ numArr = $ coincide con [0];
$ lenTmp = contar ($ numArr);
$ cubo = array_key_exists ($ lenTmp - $ i - 1, $ numArr)
? intval ($ numArr [$ lenTmp - $ i - 1])
: 0;
if (! array_key_exists ($ cubo, $ contador)) {
$ contador [$ cubo] = [];
}
$ contador [$ cubo] [] = $ arr [$ j];
}
$ pos = 0;
para ($ j = 0; $ j <cuenta ($ contador); $ j ++) {
$ valor = nulo;
if ($ contador [$ j]! == null) {
while (($ valor = array_shift ($ contador [$ j]))! == null) {
$ arr [$ pos ++] = $ valor;
}
}
}
}
return $ arr;
}
C ++
Ejemplo
int maxbit (int data [], int n) // Función auxiliar, encuentra el número máximo de dígitos de datos
{
int maxData = data [0]; /// <Número máximo
/// Encuentra el número máximo primero y luego encuentra la posición De esta manera, el número original de cada número se juzga a su vez, que está ligeramente optimizado.
for (int i = 1; i <n; ++ i)
{
if (maxData <data [i])
maxData = data [i];
}
int d = 1;
int p = 10;
while (maxData> = p)
{
// p * = 10; // Quizás overflow
maxData / = 10;
++ d;
}
return d;
/ * int d = 1; // Guarde el número máximo de dígitos
int p = 10;
for (int i = 0; i <n; ++ i)
{
while (datos [i]> = p)
{
p * = 10;
++ d;
}
}
return d; * /
}
void radixsort (int data [], int n) // Radix sort
{
int d = maxbit (data, n);
int * tmp = new int [ n];
int * count = new int [10]; // Contador
int i, j, k;
int radix = 1;
for (i = 1; i <= d; i ++) // Secuencia d veces
{
for (j = 0; j <10; j ++)
count [j] = 0; // Limpiar el contador antes de cada asignación
para (j = 0; j <n; j ++)
{
k = (data [j] / radix)% 10; // Cuente el número de registros en cada depósito
count [k] ++;
}
for (j = 1; j <10; j ++)
count [j] = count [j-1] + count [j]; // asigna la posición en tmp a cada cubo por turno
for (j = n-1; j> = 0; j--) // Recopila todos los registros del depósito en tmp a su vez
{
k = (data [j] / radix)% 10;
tmp [count [k] - 1] = data [j];
count [k] -;
}
for (j = 0; j <n; j ++) // Copia el contenido de la matriz temporal a data
data [j] = tmp [j];
radix = radix * 10;
}
eliminar [] tmp;
eliminar [] recuento;
}
C
Ejemplo
#include
#define MAX 20
// # define SHOWPASS
#define BASE 10
void print (int * a, int n) {
int i;
para (i = 0; i <n; i ++) {
printf ("% d \ t", a [i]);
}
}
void radixsort (int * a, int n) {
int i, b [MAX], m = a [0], exp = 1;
para (i = 1; i <n; i ++) {
if (a [i]> m) {
m = a [i];
}
}
while (m / exp> 0) {
int bucket [BASE] = {0};
para (i = 0; i <n; i ++) {
cubo [(a [i] / exp)% BASE] ++;
}
para (i = 1; i <BASE; i ++) {
cubo [i] + = cubo [i - 1];
}
para (i = n - 1; i> = 0; i--) {
b [- cubo [(a [i] / exp)% BASE]] = a [i];
}
para (i = 0; i <n; i ++) {
a [i] = b [i];
}
exp * = BASE;
#ifdef SHOWPASS
printf ("\ nPASS:");
imprimir (a, n);
#endif
}
}
int main () {
int arr [MAX];
int i, n;
printf ("Ingrese elementos totales (n <=% d):", MAX);
scanf ("% d", & n);
n = n <MAX? n: MAX;
printf ("Introduzca% d elementos:", n);
para (i = 0; i <n; i ++) {
scanf ("% d", & arr [i]);
}
printf ("\ nARRAY:");
radixsort (& arr [0], n);
printf ("\ nSORTED:");
imprimir (& arr [0], n);
printf ("\ n");
return 0;
}
llevar
Ejemplo
- 获取 表 中 位数
local maxBit = función (tt)
peso local = 10; - 十進制
bit local = 1;
para k, v en pares (tt) hacer
mientras v> = peso hacer
peso = peso * 10;
bit = bit + 1;
end
end
return bit;
end
- 基数 排序
local radixSort = función (tt)
local maxbit = maxBit (tt);
depósito local = {};
temperatura local = {};
base local = 1;
para i = 1, maxbit do
para j = 1, 10 do
bucket [j] = 0; --- 清空 桶
final
para k, v en pares (tt) hacer
del resto local = math.floor ((v / radix))% 10 + 1;
cubo [resto] = cubo [resto] + 1; - El número de cada cubo se incrementa automáticamente en 1
extremo
para j = 2, 10 do
cubo [j] = balde [j-1] + balde [j]; - el número de cada balde = el número anterior de baldes y + el número de
uno mismo final
- según la posición del balde, clasificación - esto es clasificación de baldes , y se debe usar el orden inverso, debido a que el método de clasificación es de pequeño a grande, el orden es descendente y el grande se borrará en el pequeño.
para k = #tt, 1, -1 do
local resto = math.floor ((tt [k] / radix))% 10 + 1;
temp [cubo [resto]] = tt [k];
cubo [resto] = cubo [resto] -1;
fin
de k, v en pares (temp) do
tt [k] = v;
raíz
final = raíz * 10;
fin
fin;