web-dev-qa-db-fra.com

Comment trier les chiffres entiers dans l'ordre croissant sans chaînes ni tableaux?

J'essaie de trier les chiffres d'un entier de n'importe quelle longueur dans l'ordre croissant sans utiliser de chaînes, de tableaux ou de récursivité.

Exemple:

Input: 451467
Output: 144567

J'ai déjà compris comment obtenir chaque chiffre de l'entier avec division du module:

int number = 4214;

while (number > 0) {
    IO.println(number % 10);
    number = number / 10;
}

mais je ne sais pas comment commander les chiffres sans tableau.

Ne vous inquiétez pas pour la classe IO; c'est un cours personnalisé que notre professeur nous a donné.

javasortingmodulo
8
klayveR

Il y a en fait un algorithme très simple, qui utilise seulement des entiers:

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);

il imprimera 1123447. L'idée est simple: 

  1. vous prenez le chiffre actuel du nombre que vous voulez trier (appelons-le N)
  2. vous passez tous les chiffres dans le numéro déjà trié (appelons-le S)
  3. si le chiffre actuel dans S est inférieur au chiffre actuel dans N, vous insérez simplement le chiffre dans la position actuelle dans S. Sinon, vous passez simplement au chiffre suivant dans S. 

Cette version de l'algorithme peut trier dans les deux ordres asc, il vous suffit de changer la condition.

Aussi, je vous suggère de jeter un coup d'oeil à ce qu'on appelle Radix Sort , la solution ici prend quelques idées de la sorte radix, et je pense que la sorte radix est le cas général pour cette solution.

6
Timofey

C'est 4 lignes, basées sur une variante de la boucle for de votre boucle while avec un peu d'épice Java 8:

int number = 4214;

List<Integer> 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)
8
Bohemian

Comment trier un nombre sans utiliser de tableau, de chaîne ou de tri api? Eh bien, vous pouvez trier un nombre en procédant comme suit (si vous avez trop de choses à lire, reportez-vous au résultat de débogage ci-dessous pour avoir une idée de la méthode de tri): 

  1. Obtenez le dernier chiffre du nombre en utilisant (digit = number% 10) 
  2. Diviser le numéro afin que le dernier chiffre soit parti (nombre/= 10) 
  3. Parcourez les chiffres du numéro (sans chiffre) et vérifiez si le chiffre est le plus petit
  4. Si un nouveau chiffre plus petit est trouvé, remplacez le chiffre = le plus petit chiffre et continuez à chercher jusqu'à la fin
  5. À la fin de la boucle, vous avez trouvé le plus petit chiffre, stockez-le (store = (magasin * 10)) + chiffre 
  6. Maintenant que vous savez qu'il s'agit du plus petit chiffre, supprimez ce chiffre du numéro et appliquez les étapes ci-dessus au nombre restant. À chaque fois qu'un chiffre plus petit est trouvé, ajoutez-le au magasin et supprimez le chiffre du nombre (si le chiffre est répété, puis supprimez-les tous et ajoutez-les au magasin) 

J'ai fourni un code avec deux boucles while dans la méthode principale et une fonction. La fonction ne fait rien, mais construit un nouvel entier en excluant le chiffre transmis, par exemple, je passe les fonctions 451567 et 1 et la fonction me renvoie 45567 (dans n'importe quel ordre, peu importe). Si cette fonction est passée à 451567 et 5 alors, il trouve les deux chiffres en nombre et les ajoute à stocker et renvoie le numéro sans 5 chiffres (ceci évite un traitement supplémentaire). 

Débogage, pour savoir comment il trie l'entier:

Le dernier chiffre est: 7 du numéro: 451567
Subchunk est 45156
Subchunk est 4515
Subchunk est 451
Subchunk est 45
Subchunk est 4
Le chiffre réduit en 451567 est 1
Le magasin est: 1
Supprimer 1 de 451567
Nombre réduit à: 76554
Le dernier chiffre est: 4 du numéro: 76554
Subchunk est 7655
Subchunk est 765
Subchunk est 76
Subchunk est 7
Le chiffre réduit en 76554 est 4
Le magasin est: 14
Supprimer 4 de 76554
Nombre réduit à: 5567
Le dernier chiffre est: 7 du numéro: 5567
Subchunk est 556
Subchunk est 55
Subchunk est 5
Le chiffre réduit en 5567 est 5
Le magasin est: 145
Supprimer 5 de 5567
Répétition du chiffre min. 5 trouvé. Le magasin est: 145
Nombre minimal répété 5 ajouté au magasin. Mise à jour du magasin: 1455
Nombre réduit à: 76
Le dernier chiffre est: 6 du nombre: 76
Subchunk est 7
Le chiffre réduit en 76 est 6
Store is: 14556
Retirer 6 de 76
Nombre réduit à: 7
Le dernier chiffre est: 7 du nombre: 7
Le chiffre réduit en 7 est 7
Store is: 145567
Retirer 7 de 7
Nombre réduit à: 0
L'ordre croissant de 451567 est 145567

L'exemple de code est le suivant: 

//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; 
     }
}
2
Raf

Je suppose que vous êtes autorisé à utiliser le hachage.

public static void sortDigits(int x) {
    Map<Integer, Integer> digitCounts = new HashMap<>();

    while (x > 0) {
        int digit = x % 10;
        Integer currentCount = digitCounts.get(digit);
        if (currentCount == null) {
            currentCount = 0;
        }
        digitCounts.put(x % 10, currentCount + 1);
        x = x / 10;
    }

    for (int i = 0; i < 10; i++) {
        Integer count = digitCounts.get(i);
        if (count == null) {
            continue;
        }
        for (int j = 0; j < digitCounts.get(i); j++) {
            System.out.print(i);
        }
    }
}
2
tharindu_DG

Mon algorithme de le faire:

int ascending(int a)
{
    int b = a;
    int i = 1;
    int length = (int)Math.log10(a) + 1;   // getting the number of digits
    for (int j = 0; j < length - 1; j++)
    {
        b = a;
        i = 1;
        while (b > 9)
        { 
            int s = b % 10;                // getting the last digit
            int r = (b % 100) / 10;        // getting the second last digit
            if (s < r)
            {
                a = a + s * i * 10 - s * i - r * i * 10 + r * i; // switching the digits
            }
            b = a;
            i = i * 10;
            b = b / i;                     // removing the last digit from the number
        }
    }
    return a;
}
1
Abbas

Ajouter un algorithme très simple qui ne nécessite aucune infrastructure de données ni mathématique sophistiquée, contrairement aux autres.

int number = 65356;
for (int i = 0; i <= 9; i++) { // the possible elements are known, 0 to 9
    int tempNumber = number;
    while (tempNumber > 0) {
        int digit = tempNumber % 10;
        IO.print(digit);
        tempNumber = number / 10;
    }
}

Dans les mots:
1. Imprimez un 0 pour chaque 0 du nombre.
2. Imprimez un 1 pour chaque 1 du nombre.
...

1
Raimund Krämer
class SortDigits {
    public static void main(String[] args) {
        int inp=57437821;
        int len=Integer.toString(inp).length();
        int[] arr=new int[len];
        for(int i=0;i<len;i++)
        {
            arr[i]=inp%10;
            inp=inp/10;
        }
        Arrays.sort(arr);
        int num=0;
        for(int i=0;i<len;i++)
        {
            num=(num*10)+arr[i];
        }
        System.out.println(num);
    }    
}
0
Arun Singh

Voici la solution simple:

    public class SortDigits
    {
        public static void main(String[] args)
        {
            sortDigits(3413657);
        }

        public static void sortDigits(int num)
        {
            System.out.println("Number  : " + num);
            String number = Integer.toString(num);
            int len = number.length(); // get length of the number
            int[] digits = new int[len];
            int i = 0;
            while (num != 0)
            {
                int digit = num % 10;
                digits[i++] = digit; // get all the digits
                num = num / 10;
            }
            System.out.println("Digit before sorting: ");
            for (int j : digits)
            {
                System.out.print(j + ",");
            }
            sort(digits);
            System.out.println("\nDigit After sorting: ");
            for (int j : digits)
            {
                System.out.print(j + ",");
            }
        }
        //simple bubble sort 
        public static void sort(int[] arr)
        {
            for (int i = 0; i < arr.length - 1; i++)
                for (int j = i + 1; j < arr.length; j++)
                {
                    if (arr[i] > arr[j])
                    {
                        int tmp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = tmp;
                    }
                }
        }
    }
0
Pushparaj Dhole