Colección.sort ()
La clasificación de Java se puede implementar con CollectIleos.sort ().
Hay dos métodos para ordenar la lista con el método de colección.
El primero es el objeto en la lista para implementar la interfaz comparable, como sigue:
/*** Ordene al usuario de acuerdo con el orden*/Public Class Inmemements Comparable <Serve> {Nombre de la cadena privada; nombre;} public Integer getrder () {Orden de retorno;} public void setorder (orden entero) {this.order = orden;} public int Compareto (User Arg0) {rn this.getorder (). );}} Prueba:
Public Class Test {public static void main (string [] art) {user user1 = new user (); ); (lista); El resultado de la salida es el siguiente
Abundante
El segundo método es lograr basado en el método de carga de la colección.sort, como ::
/*** Ordene al usuario de acuerdo con el orden*/Usuario de clase pública {// No es necesario implementar la interfaz comparable. Orden de retorno;} public void setOrder (orden entero) {this.order = orden;}}} Escribe en la clase principal ::
Public Class Test {public static void main (string [] art) {user user1 = new user (); ); Int Compare (User Arg0, user arg1) {return arg0.getOrder (). getName ());}}} El resultado de la salida es el siguiente
Abundante
La estructura de código anterior es simple, pero solo se puede ordenar de acuerdo con los atributos fijos.
Elija lo mejor.
Algoritmo de clasificación común
Veamos la práctica del código Java con varios algoritmos de clasificación clásica:
Clasificación de burbujas
Public static void bubblesort (int a [], int n) {int i, j; j ++) {if (a [j]> a [j + 1]) {a [j] = a [j] ^ a [j + 1]; [j + 1];Insertar directamente la clasificación
Public static void InsertSort (int a [], int n) {int i, j, tmp; ; ;}}}Elija directamente
Public static void selectsort (int a [], int n) {int i, j, local; n; [loc] = a [i] ^ a [loc];Clasificación
/ ** * sort de montón (de pequeño a grande) * * * @param a * @param n */ public static void Heapsort (int a [], int n) {int tmp; n); 0, j);}} / ** * Construya muchas raíces * * * * * * @param a * @param n * / private static void buildmaxheap (int a [], int n) {for (int i = (( n -2) / 2; i> = 0; I * @param n * / private static void maxHeapify (int a [], int i, int n) {int izquierdo, derecho, local; i + 2; ;} if (loc! = i) {a [i] = a [loc] ^ a [i]; a [i];} else {break;}}}Clasificación rápida
Public static void Quicksort (int a [], int bt, int ed) {if (bt <ed) {int pivot = pivotputition (a, bt, ed); 1, ed);}} privado void swapvar (int a [], int bt, int) {int mid = bt + (ed -bt) / 2; ) bt] = a [bt] ^ a [Mid]; Bt, int ed) {// Tome el valor intermedio como soporte para evitar la matriz en una apariencia ordenada o (n^2) Situación 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] = state;Unir
Public static void Mergesort (int a [], int bt, int ed) {if (bt <ed) {int mid = bt + (ed -bt) / 2; Ed); ; = A [j]) {tmp [k] = a [i ++];} else {tmp [k] = a [j ++];} while (j <= ed) {tmp [k ++ ] = a [j ++];} para (i = 0; i <k; i ++) {a [bt+i] = tmp [i];}}Programa de prueba
Ven y resume el algoritmo anterior:
Import java.util.scanner; cin.nextint (); ; / Insertar (a, 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; 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 [] = nuevo 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 ++];} para (i = 0; i <k; i ++) {a [ bt+i] = tmp [i];} / ** * ordenar rápidamente * * * @param a * @param bt * @param ed * / public static void Quicksort (int a [], int bt, int ed) { If (bt <ed) {int pivot) = PivotPartition (a, bt, ed); a [], int bt, int ed) {int mid = bt + (ed -bt) / 2; ] = a [bt] [mid]; param eds * @return */ private static int pivotPartition (int a [], int bt, int ed) {// Tome el valor intermedio como soporte para evitar la matriz en una apariencia ordenada 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; // construye una gran pila de construidos [j]; [], int n) {for (int i = (n -2) / 2; i> = 0; i-) {maxHeapifify (a, i, n);} / ** * Mantenimiento La pila máxima de mantenimiento comienza Desde la oferta i * * * * @param a * @param n * / private static void maxHeapify (int a [], int i, int n) {int izquierdo, derecho, local (i <n) {izquierda = 2 * i + 1; ]) {i = right;} if (loc! = i) {a [a) i] = a [loc] ^ a [i]; i] = a [loc] ^ a [i];} else {break;}}}}} / ** * Seleccione la clasificación directamente * * * @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]; (int a [], int n) {int i, j, tmp; 0; ordenar * * * @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 [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]);}}}}}}