web-dev-qa-db-fra.com

trier les entiers dans l'ordre le plus bas au plus élevé java

Ces nombres sont stockés dans la même variable entière. Comment pourrais-je procéder pour trier les nombres entiers par ordre croissant?

11367 
 11358 
 11421 
 11530 
 11491 
 11218 
 11789
javaalgorithmsortinginteger
4
user983246

Il y a vraiment deux options: 

  1. Utilisez des collections standard, comme expliqué par Shakedown
  2. Utilisez Arrays.sort

Par exemple.,

int[] ints = {11367, 11358, 11421, 11530, 11491, 11218, 11789};
Arrays.sort(ints);
System.out.println(Arrays.asList(ints));

Bien entendu, cela suppose que vous avez déjà vos entiers sous forme de tableau. Si vous devez d'abord les analyser, recherchez String.split et Integer.parseInt .

15
alf

Vous pouvez les mettre dans une liste puis les trier en utilisant leur ordre naturel, comme suit:

final List<Integer> list = Arrays.asList(11367, 11358, 11421, 11530, 11491, 11218, 11789);
Collections.sort( list );
// Use the sorted list

Si les nombres sont stockés dans la même variable, vous devrez les placer d'une manière ou d'une autre dans une variable List, puis appeler sort, comme suit:

final List<Integer> list = new ArrayList<Integer>();
list.add( myVariable );
// Change myVariable to another number...
list.add( myVariable );
// etc...

Collections.sort( list );
// Use the sorted list
5
Nate W.

Eh bien, si vous voulez le faire en utilisant un algorithme. Il existe une pléthore d'algorithmes de tri. Si vous n'êtes pas trop préoccupé par l'efficacité et par la lisibilité et la compréhensibilité. Je recommande le tri par insertion. Voici le code psudo, il est trivial de le traduire en Java.

begin
    for i := 1 to length(A)-1 do
    begin
        value := A[i];
        j := i - 1;
        done := false;
        repeat
            { To sort in descending order simply reverse
              the operator i.e. A[j] < value }
            if A[j] > value then
            begin
                A[j + 1] := A[j];
                j := j - 1;
                if j < 0 then
                    done := true;
            end
            else
                done := true;
        until done;
        A[j + 1] := value;
    end;
end;
3
Suraj Kulkarni

Pour trier une plage étroite d’entiers, essayez Compter avec le type , dont la complexité est de O(range + n), où n est le nombre d’éléments à trier. Si vous souhaitez trier quelque chose non discret, utilisez les algorithmes optimaux n * log (n) ( quicksort , heapsort , mergesort ). Le tri par fusion est également utilisé dans une méthode déjà mentionnée par d'autres réponses Arrays.sort. Il n’existe aucun moyen simple de recommander un appel d’algorithme ou de fonction, car il existe des dizaines de cas spéciaux dans lesquels vous utiliseriez une sorte, mais pas l’autre. 

Veuillez donc spécifier le but exact de votre application (pour apprendre quelque chose (commencez par le tri par insertion ou par bulle), efficacité pour les entiers (utilisation du comptage), efficacité et possibilité de réutilisation pour les structures (utilisez les algorithmes n * log (n)) , ou vous voulez simplement que cela soit trié - utilisez Arrays.sort :-)). Si vous souhaitez trier les représentations sous forme de chaîne d'entiers, alors u pourrait être interressé par un tri de base ....

2
malejpavouk

Prendre des entrées de l'utilisateur et le tri par insertion. Voici comment cela fonctionne:

package com.learning.constructor;

import Java.util.Scanner;



public class InsertionSortArray {

public static void main(String[] args) {    

Scanner s=new Scanner(System.in);

System.out.println("enter number of elements");

int n=s.nextInt();


int arr[]=new int[n];

System.out.println("enter elements");

for(int i=0;i<n;i++){//for reading array
    arr[i]=s.nextInt();

}

System.out.print("Your Array Is: ");
//for(int i: arr){ //for printing array
for (int i = 0; i < arr.length; i++){
    System.out.print(arr[i] + ",");

}
System.out.println("\n");        

    int[] input = arr;
    insertionSort(input);
}

private static void printNumbers(int[] input) {

    for (int i = 0; i < input.length; i++) {
        System.out.print(input[i] + ", ");
    }
    System.out.println("\n");
}

public static void insertionSort(int array[]) {
    int n = array.length;
    for (int j = 1; j < n; j++) {
        int key = array[j];
        int i = j-1;
        while ( (i > -1) && ( array [i] > key ) ) {
            array [i+1] = array [i];
            i--;
        }
        array[i+1] = key;
        printNumbers(array);
    }
}

}
0
Deepak Manktala

si array.sort n'a pas ce que vous cherchez, vous pouvez essayer ceci:

package drawFramePackage;
import Java.awt.geom.AffineTransform;
import Java.util.ArrayList;
import Java.util.ListIterator;
import Java.util.Random;
public class QuicksortAlgorithm {
    ArrayList<AffineTransform> affs;
    ListIterator<AffineTransform> li;
    Integer count, count2;
    /**
     * @param args
     */
    public static void main(String[] args) {
        new QuicksortAlgorithm();
    }
    public QuicksortAlgorithm(){
        count = new Integer(0);
        count2 = new Integer(1);
        affs = new ArrayList<AffineTransform>();
        for (int i = 0; i <= 128; i++){
            affs.add(new AffineTransform(1, 0, 0, 1, new Random().nextInt(1024), 0));
        }
        affs = arrangeNumbers(affs);
        printNumbers();
    }
    public ArrayList<AffineTransform> arrangeNumbers(ArrayList<AffineTransform> list){
        while (list.size() > 1 && count != list.size() - 1){
            if (list.get(count2).getTranslateX() > list.get(count).getTranslateX()){
                list.add(count, list.get(count2));
                list.remove(count2 + 1);
            }
            if (count2 == list.size() - 1){
                count++;
                count2 = count + 1;
            }
            else{
            count2++;
            }
        }
        return list;
    }
    public void printNumbers(){
        li = affs.listIterator();
        while (li.hasNext()){
            System.out.println(li.next());
        }
    }
}
0
Nathan Nelson