Collection.Sort ()
Le tri de Java peut être mis en œuvre avec ColleCTILEOS.Sort ().
Il existe deux méthodes pour trier la liste avec la méthode des collections.
Le premier est l'objet dans la liste pour implémenter l'interface comparable, comme suit:
/ *** Trier l'utilisateur en fonction de la commande * / public de la classe publique implémente <utilisateur> {nom de chaîne privée; Nom;} public Integer GetRder () {Retour Ordre;} public void SetOrder (INTEGER ORDER) {this.order = order;} public int compareto (utilisateur arg0) {rn this.getOrder (). );}} Test:
Classe publique Test {public static void (String [] art) {User User1 = new User (); user1.setname ("a"); user1.set. ); (list); pour (user u: list) {System.out.println (u.getName ());} Le résultat de sortie est le suivant
AB
La deuxième méthode consiste à réaliser en fonction de la méthode de chargement des collectes.Sort, comme ::
/ *** Triez l'utilisateur en fonction de l'ordre * / classe publique utilisateur {// il n'est pas nécessaire d'implémenter l'interface comparable. Ordre de retour;} public void setOrder (ordre entier) {this.order = ordre;}}} Écrivez dans la classe principale ::
Classe publique Test {public static void (String [] Art) {User User1 = New User (); ); Int compare (utilisateur arg0, utilisateur arg1) {return arg0.getOrder (). getName ());}}} Le résultat de sortie est le suivant
AB
La première structure de code est simple, mais elle ne peut être triée que selon les attributs fixes.
Choisissez le meilleur.
Algorithme de tri commun
Regardons la pratique du code Java avec plusieurs algorithmes de tri classiques:
Tri à bulles
Public static void bubblesort (int a [], int n) {int i, j; pour (i = 0; i <n -1; i ++) {pour (j = 0; j <n -i -1; j ++) {if (a [j]> a [j + 1]) {a [j] = a [j] ^ a [j + 1]; [J + 1]; A [J] = A [J] ^ A [J + 1];}}Insérer directement le tri
InsertSort statique public (int a [], int n) {int i, j, tmp; pour (i = 1; i <n; i ++) {tmp = a [i]; ; j; j> = 0; j--) {if (a [j]> tmp) ;}}}Choisissez directement
Public static void seletsort (int a [], int n) {int i, j, local; n; [loc] = a [i] ^ a [loc];Tri
/ ** * Toile de tas (de petit à grand) * * * @param a * @param n * / public static void heapsort (int a [], int n) {int tmp; n); 0, j);}} / ** * construire beaucoup de racines * * * * * @param a * @param n * / private static void buildMaxheap (int a [], int n) {for (int i = ( n -2) / 2; i> = 0; i-) {maxheapify (a, i, n);} / ** * I * @param n * / private static void maxheapify (int a [], int i, int n) {int Left, droite, local; i + 2; loc = i; ;} if (loc! = i) {a [i] = a [loc] ^ a [i]; a [i];} else {Break;}}}Tri rapide
Public static void Quicksort (int a [], int bt, int ed) {if (bt <ed) {int pivot = pivotpution (a, bt, ed); 1, ed);}} private static void swapvar (int a [], int bt, int ed) {int mid = bt + (ed -bt) / 2; ) bt] = a [bt] ^ a [mid]; a [mid] = a [bt] ^ a [mid]; Bt, int ed) {// prenez la valeur intermédiaire en stand pour empêcher le tableau dans une apparence ordonnée o (n ^ 2) la situation swapvar (a, bt, ed); Ed) {while (bt <ed && a [ed]> = stand) {ed-;} if (bt <ed) {a [bt ++] = a [ed]; bt ++;} if (bt <ed) {a [eds ---] = a [bt];} [bt] = état;}}Fusionner
Public static void Mergesort (int a [], int bt, int ed) {if (bt <ed) {int mid = bt + (ed -bt) / 2; Ed); MergeArray (a, bt, mid, ed);}} private static void mergearray (int a [], int bt, int, int ed) {int i, j, k, len = ed -bt + 1 ; = A [j]) {tmp [k] = a [i ++];} else {tmp [k] = a [j ++];} while (j <= ed) {tmp [k ++ ] = a [j ++];} pour (i = 0; i <k; i ++) {a [bt + i] = tmp [i];}}Programme de test
Venez résumer l'algorithme ci-dessus:
Import java.util.scanner; classe publique javasort {public static void main (String args []) {scanner cin = new scanner (system.in); cin.Nextint (); a = new int [n]; ; ** * Merge Sort * * * @param a * @param bt * @param eds * / public static void memort (int a [], int bt, int ed) {if <ed) {int mid = bt + (ed -BT) / 2; Mergesort (a, bt, mid); Param bt * @param mid * @param ed * / private static void mergearray (int a [], int bt, int mid, int ed) {int i, j, k, k, len = ed -bt + 1; Tmp [] = new int [len]; <= a [j]) {tmp [k] = a [i ++];} else {tmp [k] = a [j ++];}} while (i <= mid) {tmp [k ++ ] = A [i ++];} while (j <= ed) {tmp [k ++] = a [j ++];} pour (i = 0; i <k; i ++) {a [ bt + i] = tmp [i];} / ** * Trier rapidement * * * @param a * @param bt * @param ed * / public static void QuickSort (int a [], int bt, int ed) { If (bt <ed) {int pivot) = pivotPartion (a, bt, ed); a [], int bt, int ed) {int mid = bt + (ed -bt) / 2; ] = a [bt] [mid]; a [bt] = a [bt] ^ a [mid];}} / ** * ligne rapide pour trouver la position du point de référence * * @param a * @param bt * @ Param eds * @return * / private static int pivotPartition (int a [], int bt, int ed) {// prenez la valeur intermédiaire en stand pour empêcher le tableau dans une apparence ordonnée o (n ^ 2) swapvar (a, bt, ed); +] = a [ed];} while (bt <ed && a [bt] <= stand) {bt ++;} if (bt <ed) {a [eds ---] = a [bt];} a [bt] = stand; ) {int tmp; [j]; a [j] = tmp; [], int n) {for (int i = (n -2) / 2; i> = 0; i-) {maxHeapify (a, i, n);} / ** * Maintenance le tas maximum de maintenance Démarrage de l'offre i * * * * @param a * @param n * / private static void maxheapify (int a [], int i, int n) {int Left, droite, local; 2 * i + 1; droit = 2 * i + 2; ]) {i = droit;} if (loc! = i) {a [a) i] = a [loc] ^ a [i]; i] = a [loc] ^ a [i];} else {Break;}}}}} / ** * sélectionnez le tri directement * * * @param a * @param n * / public static void selectSort (int a [ ], int n) {int i, j, local; (a [j] <a [loc]) {loc = j;}} if (loc! = i) {a) {a) [i] = a [i] ^ a [loc]; a [i] ^ a [loc]; a [i] = a [i] ^ a [loc];}} / ** * (int a [], int n) {int i, j, tmp; 0; Trier * * * @param a * @param n * / public static void bubblesort (int a [], int n) {int i, j; (j = 0; j <n -i -1; j ++) {if (a [j]> a [j + 1]) {a [a j] = a [j] ^ a [j + 1]; * @param a * / public static void printarr (int a []) {for (int i = 0; i <.length; i ++) {if (i == a.length -1) {System.out. printf ("% d / n", a [i]);} else {System.out.printf ("% d", a [i]);}}}}}}