tri des entiers dans l'ordre du plus bas au plus haut java

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

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, alors vous devrez en quelque sorte les mettre dans un List puis appeler sort, comme ceci:

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

• Collections.sort( List )

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

Pour le tri gamme étroite d'entiers try Comptage tri, qui a une complexité de O(range + n), où n est le nombre d'éléments à trier. Si vous souhaitez trier quelque chose qui n'est pas discret, utilisez des 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'y a pas de moyen simple de recommander un algorithme ou un appel de fonction, car il existe des dizaines de cas particuliers, où vous serait d'utiliser une certaine sorte, mais pas les autres.

Veuillez donc spécifier le but exact de votre application (apprendre quelque chose (bien commencer par le tri par insertion ou le tri par bulle), l'efficacité pour les entiers (utiliser le tri par comptage), l'efficacité et la réutilisabilité pour les structures (utiliser des algorithmes n*log(n))), ou zou veut juste qu'il soit trié - utilisez des tableaux.sorte :-)). Si vous souhaitez trier les représentations de chaînes d'entiers, u peut être interressé dans radix sort....

Si tableau.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());
        }
    }
}

Prenez les entrées de l'utilisateur et le Tri d'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);
    }
}

}