Posterior a de nuestra extensa búsqueda de información solucionamos este atasco que presentan muchos de nuestros lectores. Te ofrecemos la respuesta y nuestro objetivo es serte de mucha apoyo.
Solución:
Son 4 líneas, basadas en un for variante de bucle de su bucle while con un poco de sabor java 8:
int number = 4214;
List numbers = new LinkedList<>(); // a LinkedList is not backed by an array
for (int i = number; i > 0; i /= 10)
numbers.add(i % 10);
numbers.stream().sorted().forEach(System.out::println); // or for you forEach(IO::println)
De hecho, existe un algoritmo muy simple, que usa solo enteros:
int number = 4214173;
int sorted = 0;
int digits = 10;
int sortedDigits = 1;
boolean first = true;
while (number > 0)
int digit = number % 10;
if (!first)
int tmp = sorted;
int toDivide = 1;
for (int i = 0; i < sortedDigits; i++)
int tmpDigit = tmp % 10;
if (digit >= tmpDigit)
sorted = sorted/toDivide*toDivide*10 + digit*toDivide + sorted % toDivide;
break;
else if (i == sortedDigits-1)
sorted = digit * digits + sorted;
tmp /= 10;
toDivide *= 10;
digits *= 10;
sortedDigits += 1;
else
sorted = digit;
first = false;
number = number / 10;
System.out.println(sorted);
se imprimirá 1123447. La idea es simple:
- toma el dígito actual del número que desea ordenar (llamémoslo N)
- pasas por todos los dígitos en un número ya ordenado (llamémoslo S)
- Si el dígito actual en S es menor que el dígito actual en N, simplemente inserte el dígito en la posición actual en S. De lo contrario, simplemente vaya al siguiente dígito en S.
Esa versión del algoritmo puede ordenar en ambos asc en órdenes desc, solo tiene que cambiar la condición.
Además, le sugiero que eche un vistazo al llamado Radix Sort, la solución aquí toma algunas ideas del Radix Sort, y creo que el Radix Sort es el caso general para esa solución.
Cómo ordenar un número sin usar array, string o api de clasificación? Bueno, puede ordenar un número con los siguientes pasos simples (si es demasiado para leer, vea el resultado de depuración a continuación para tener una idea de cómo se realiza la clasificación):
- Obtenga el último dígito del número usando (dígito = número% 10)
- Divida el número para que desaparezca el último dígito (número / = 10)
- Recorra los dígitos del número (que no tiene dígito) y compruebe si el dígito es el más pequeño
- Si se encuentra un nuevo dígito más pequeño, reemplace el dígito = dígito más pequeño y siga buscando hasta el final
- Al final del ciclo, ha encontrado el dígito más pequeño, guárdelo (almacenar = (almacenar * 10) + dígito
- Ahora que sabe que este es el dígito más pequeño, elimine este dígito del número y siga aplicando los pasos anteriores al número restante y cada vez que encuentre un dígito más pequeño, agréguelo a la tienda y elimine el dígito del número (si el dígito se repite en el número, luego elimínelos todos y agréguelos a la tienda)
Proporcioné un código con dos bucles while en el método principal y una función. La función no hace más que construir un nuevo entero excluyendo el dígito que se le pasa, por ejemplo, le paso la función 451567 y 1 y la función me devuelve 45567 (en cualquier orden, no importa). Si esta función se pasa 451567 y 5, busca ambos 5 dígitos en el número y los agrega para almacenar y devolver el número sin 5 dígitos (esto evita el procesamiento adicional).
Depurando, para saber cómo ordena el entero:
El último dígito es: 7 del número: 451567
Subchunk es 45156
Subchunk es 4515
Subchunk es 451
Subchunk tiene 45
Subchunk es 4
El dígito reducido en 451567 es 1
La tienda es: 1
Quitar 1 de 451567
El número reducido es: 76554
El último dígito es: 4 del número: 76554
Subchunk es 7655
Subchunk es 765
Subchunk tiene 76
Subchunk es 7
El dígito reducido en 76554 es 4
La tienda es: 14
Quitar 4 de 76554
El número reducido es: 5567
El último dígito es: 7 del número: 5567
Subchunk es 556
Subchunk tiene 55
Subchunk es 5
El dígito reducido en 5567 es 5
La tienda es: 145
Quitar 5 de 5567
Se encontró el dígito 5 mínimo repetido. La tienda es: 145
Se agregó el dígito 5 mínimo repetido a la tienda. La tienda actualizada es: 1455
El número reducido es: 76
El último dígito es: 6 del número: 76
Subchunk es 7
Un dígito pequeño en 76 es 6
La tienda es: 14556
Quitar 6 de 76
El número reducido es: 7
El último dígito es: 7 del número: 7
El dígito reducido en 7 es 7
La tienda es: 145567
Quitar 7 de 7
El número reducido es: 0
El orden ascendente de 451567 es 145567
El código de muestra es el siguiente:
//stores our sorted number
static int store = 0;
public static void main(String []args)
int number = 451567;
int original = number;
while (number > 0)
//digit by digit - get last most digit
int digit = number % 10;
System.out.println("Last digit is : " + digit + " of number : " + number);
//get the whole number minus the last most digit
int temp = number / 10;
//loop through number minus the last digit to compare
while(temp > 0)
System.out.println("Subchunk is " + temp);
//get the last digit of this sub-number
int t = temp % 10;
//compare and find the lowest
//for sorting descending change condition to t > digit
if(t < digit)
digit = t;
//divide the number and keep loop until the smallest is found
temp = temp / 10;
System.out.println("Smalled digit in " + number + " is " + digit);
//add the smallest digit to store
store = (store * 10) + digit;
System.out.println("Store is : " + store);
//we found the smallest digit, we will remove that from number and find the
//next smallest digit and keep doing this until we find all the smallest
//digit in sub chunks of number, and keep adding the smallest digits to
//store
number = getReducedNumber(number, digit);
System.out.println("Ascending order of " + original + " is " + store);
/*
* A simple method that constructs a new number, excluding the digit that was found
* to b e smallest and added to the store. The new number gets returned so that
* smallest digit in the returned new number be found.
*/
public static int getReducedNumber(int number, int digit)
System.out.println("Remove " + digit + " from " + number);
int newNumber = 0;
//flag to make sure we do not exclude repeated digits, in case there is 44
boolean repeatFlag = false;
while(number > 0)
int t = number % 10;
//assume in loop one we found 1 as smallest, then we will not add one to the new number at all
if(t != digit)
newNumber = (newNumber * 10) + t;
else if(t == digit)
if(repeatFlag)
System.out.println("Repeated min digit " + t + "found. Store is : " + store);
store = (store * 10) + t;
System.out.println("Repeated min digit " + t + "added to store. Updated store is : " + store);
//we found another value that is equal to digit, add it straight to store, it is
//guaranteed to be minimum
else
//skip the digit because its added to the store, in main method, set flag so
// if there is repeated digit then this method add them directly to store
repeatFlag = true;
number /= 10;
System.out.println("Reduced number is : " + newNumber);
return newNumber;
}