Hola a todos, soy un pato:
Hoy en día la base de compartir algoritmo radix tipo de pedidos.
1. Base Ordenar:
Principio: radix sort (radix especie) están "asignado de pedido" (distribución especie), también conocida como "Ley de cubo" (cubo especie) o tipo bin.
Todos los valores que se compararán (un entero positivo) para el mismo número de longitud de bits uniforme, el número más corto de dígitos con ceros a la izquierda. Entonces, desde el más bajo de inicio, una vez ordenados. Esto ha sido ordenados desde el más bajo al más alto orden de los bits se ha completado, la serie se convierte en una secuencia ordenada.
ideas:
Radix sort, a saber, una un bit digital para clasificar, un algoritmo idea que a menudo utilizan la vida ordinaria: Si quiere hasta la fecha de clasificación, fecha por año, mes, día que consiste en, por lo demás, a menudo el uso es el primer año de la comparación, si la misma, comparar el mes, si todavía relativamente el mismo día.
Los siguientes cuatro números ordenar: 123,312,245,531
Bits => diez => cien
53 1 3 1 2 1 23
31 2 1 2 3 2 45
12 3 5 3 1 3 12
24 5 2 4 5 5 31
la implementación del código:
/**
* 基数排序
* @param d
* @param array
* 时间复杂度 O的log2 N
* 基数排序 运用二维数组来分别比较每一位，个位、十位、百位…
* 输入10个整数的数组
*/
private void radixSort(int d,int[] array){
long nowTime = System.nanoTime();
int n=1;//代表位数对应的数：1,10,100000...
int k=0;//保存每一位排序后的结果用于下一位的排序输入
int[][] bucket=new int[10][array.length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
int[] num=new int[array.length];//用于保存每个桶里有多少个数字 ,最多为输入数组长度
while(n<=d)
{
for(int e:array) //将数组array里的每个数字放在相应的桶里
{
int digit=(e/n)%10;
bucket[digit][num[digit]]=e;
num[digit]++;
}
for(int i=0;i<array.length;i++)//将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
{
if(num[i]!=0)//这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
{
for(int j=0;j<num[i];j++)
{
array[k]=bucket[i][j];
k++;
}
}
num[i]=0;//将桶里计数器置0，用于下一次位排序
}
n*=10;
k=0;//将k置0，用于下一轮保存位排序结果
}
System.out.println("基数排序，花费时间(ms):" + ((System.nanoTime() - nowTime) / 1000000.0) + "ms");
}algoritmo de ordenación Radix es estable, muy eficiente, que la complejidad es O (n log (r) m), donde r es el radix tomado, y m es el número de montones. Pero sólo puede estar en la clase de números enteros, y la necesidad de utilizar un espacio suplementario.
La limitación anterior es que una parte del código aplicada al valor de grupo seleccionado:
int [] x = {25 ,11 ,22 ,34 ,15 ,44 ,76, 66, 100, 8 ,14, 20 ,2, 5 ,1 };Por ejemplo, esta matriz, la base debe ser seleccionado 3. Adjuntar un método de selección del valor base.
/**
* 获取基数排序中的基数
* @param array
* @return
*/
public int getRadixBasicNumber(int[] array){
if(array == null && array.length ==0) {
return 0;
}
int max =0;
//1获取最大的绝对值的数
for(int i =0;i<array.length;i++) {
if(Math.abs(max)<Math.abs(array[i])) {
max = array[i];
}
}
int times = 0;
if(max<0) max = -max;
//2求出最大的绝对值的数，是10的times次幂。
while(max >0) {
max = max/10;
times ++;
}
return times;
}
Tiempo de comparación:
piezas figura 10W de ejecución de datos al azar:
Respectivamente, en comparación radix tipo, en línea especie, cáscara especie, y tipo rápido. Gap es obvia.
piezas figura 50W de ejecución de datos al azar:
Respectivamente, en comparación radix tipo, en línea especie, cáscara especie, y tipo rápido. Gap es obvia.
piezas figura 100W de ejecución de datos al azar:
Respectivamente, en comparación radix tipo, en línea especie, cáscara especie, y tipo rápido. Gap es obvia.
resumen:
Radix sort
Ventajas: alta eficiencia.
Desventajas: gran capacidad de memoria, único tipo de números enteros positivos (una matriz bidimensional hacer barriles)
El tiempo de peor complejidad: O (P (N + B)).
La complejidad tiempo promedio es: O (P (N + B)).
Donde p es el número de veces de clasificación, siendo N el número de elementos a clasificar, B es el número de barriles.
Comparar varios métodos de clasificación:
Más algoritmo de ordenación:
Ordenamiento de burbuja: https://blog.csdn.net/Angry_Mills/article/details/81057900
La ordenación por inserción: https://blog.csdn.net/Angry_Mills/article/details/81208700
Ordenar rápida: https://blog.csdn.net/Angry_Mills/article/details/83339390
