Collections.sort ()
Java's sorting can be implemented with collectileos.sort ().
There are two methods to sort the list with the Collections.Sort method:
The first is the object in List to implement the Comparable interface, as follows:
/*** Sort the User according to the Order*/Public Class User Implements Comparable <user> {Private String name; Private Integer Order; Public String Getname () e;} Public void setname (string name) {this.name = name;} Public Integer GetRder () {Return Order;} Public Void SetOrder (Integer Order) {this.Order = Order;} Public Int Compareto (User ARG0) { rn this.getOrder (). Compareto (arg0.getOrder () );}} Test:
Public class test {public static void main (string [] art) {user user1 = new user (); user1.setName ("a"); user1.SetOrder (1); ser (); User2.setName ("B"); User2.Setorder (2); list <user> list = new arrayList <user> (); // Here is add user2 and then add user1 list.add (user2); list.add (user1); Collections.sort (list); for (user u: list) {system.out.println (u.getName ());}} The output result is as follows
AB
The second method is to achieve based on the loading method of collections.sort, such as::
/*** Sort the User according to Order*/Public Class User {// There is no need to implement the comparable interface. } PUBLIC VOID SETNAME (String name) {this .name = name;} Public Integer GetOnter () {Return Order;} Public Void SetOrder (Integer Order) {this.Order = Order;}}} Write in the main class::
Public class test {public static void main (string [] art) {user user1 = new user (); user1.setName ("a"); user1.SetOrder (1); ser (); User2.setName ("B"); User2.setorder (2); list <user> list = new arrayList <user> (); list.add (user2); list.add (user1); collection (list, new comparator < User> () {Public Int Compare (User ARG0, User ARG1) {Return ARG0.getOrder (). Compareto (Arg1.getOrder ());}}); for (user u: list) {system.out.prin. TLN (TLN ( u.getName ());}}} The output result is as follows
AB
The former code structure is simple, but it can only be sorted according to the fixed attributes. The latter is flexible and can be temporarily specified for sorting items, but the code is not simple enough
Choose the best.
Common sorting algorithm
Let's look at the practice of Java code with several classic sorting algorithms:
Bubble sorting
Public Static void Bubblesort (int a [], int n) {int i, j; for (i = 0; i <n -1; i ++) {for (j = 0; j <n -i -1; j ++) {if (a [j]> a [j + 1]) {a [j] = a [j] ^ a [j + 1]; a [j + 1] = a [j] ^ a [j + 1]; a [j] = a [j] ^ a [j + 1];}}}Directly insert sort
Public Static void Insertsort (int a [], int n) {int i, j, tmp; for (i = 1; i <n; i ++) {tmp = a [i]; for (j = i -1; j; j > = 0; J--) {if (a [j]> tmp) {a [j + 1] = a [j];} else {break;}} a [j + 1] = tmp;}}}Choose directly
Public Static Void SELECTSORT (int a [], int n) {int i, j, local; for (i = 0; i <n; i ++) {loc = i; for (j = i+1; j <n; j ++) {if (a [j] <a [loc]) {loc = j;}} if (loc! = i) {a [i] = a [i] ^ a [loc]; a [loc] = A [i] ^ a [loc]; a [i] = a [i] ^ a [loc];}}}Sorting
/ ** * Heap sort (from small to large) * * * @param a * @param n */ public static void heapsort (int a [], int n) {int TMP; // Construct large roots builtmaxheap (a, n) ; for (int j = n - 1; j >= 1; j--) { tmp = A[0]; A[0] = A[j]; A[j] = tmp; maxheapIfy(A, 0, j);}} / ** * Construct a lot of roots * * * * * @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);} / ** * Maintenance The maximum pile of maintenance starting from the bid I * * * @Param A * @param I * @Param n * / Private Static void maxheapify (int a [], int i, int n) {int left, right, local; about (i <n) {left = 2 * i + 1; right = 2 * i + 2; loc = i; if (left <n && a [left]> a [i]) {i = left;} if (right <n && a [right]> a [i]) {i = right;} if (LOC! = i ) {A [i] = a [loc] ^ a [i]; a [loc] = a [loc] ^ a [i]; a [i] = a [loc] ^ a [i];} else { break;}}}Fast sorting
Public Static void Quicksort (int a [], int Bt, int ED) {if (bt <ed) {int Pivot = pivotputition (a, bt, ed); quicksort (a, bt, pivot -1); , Pivot + 1, ED);}} Private Static Void Swapvar (int a [], int Bt, int ED) {int mid = bt + (ed -bt) / 2; if (mid! = bt) {a [a [a) bt] = a [bt] ^ a [mid]; a [mid] = a [bt] ^ a [mid]; a [bt] = a [bt] ^ a [mid]; int a [], int Bt, int ED) {// Take the intermediate value as stand to prevent the array in an orderly appearance O (n^2) situation swapvar (a, bt, ed); int Stand = a [bt]; about (BT <ED) {While (BT <ED && A [ED]> = Stand) {ED-;} if (bt <ed) {a [bt ++] = a [ed]; A [bt] <= Stand) {bt ++;} if (bt <ed) {a [eds ---] = a [bt];} [bt] = state; return bt;}Merge
Public Static Void Mergesort (int a [], int Bt, int ED) {if (bt <ed) {int MID = BT + (ED -BT) / 2; Mergesort (a, bt, mid); MID + 1, ED); Mergearray (a, Bt, MID, ED);}} PRIVATE Static Void MergeArray (int a [], int Bt, int MID, int ED) {int i, j, k, len = ed -BT + 1; int TMP [] = new int [len]; for (i = bt, j = mid + 1, k = 0; i <= mid && j <= ed; k ++) {if (a [i ] <= A [j]) {tmp [k] = a [i ++];} else {tmp [k] = a [j ++]; ];} While (j <= ED) {tmp [k ++] = a [j ++];} for (i = 0; i <k; i ++) {a [bt+i] = tmp [i];}}Test program
Come and summarize the above algorithm:
Import java.util.Scanner; Public Class Javasort {Public Static Void Main (String ARGS []) {Scanner Cin = New Scanner (System.in); int a [], while (cin.has Next ()) {n = cin.nextint (); a = new int [n]; for (int i = 0; i <n; i ++) {a [i] = cin.nextint ();} // bubblesort (a, n); // insertsort (a, n); // selectsort (a, n); // heapsort (a, n); // quicksort (a, 0, n -1); ; Printarr (a);}} / ** * 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); Mergesort (a, MID + 1, ED); Mergearray (a, Bt, MID, ED);} / ** * Merge array * @param a * @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; int TMP [] = New Int [Len]; for (i = BT, J = MID + 1, K = 0; I <= mid && j <= ed; k ++) {if) {if (A [i] <= 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 ++];} for (i = 0; i <k; i ++) {a [bt+i] = tmp [i] ;} / ** * Quickly sort * * * @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); quicksort (a, bt, pivot -1); quicksort (a, pivot + 1, ed);}} PRIVATE Static void Swapvar (int a [], int bt, int ED) {int mid = bt + (ed -bt) / 2; if (mid! = Bt) {a [bt] = a [bt] ^ a [mid]; a [mid] = a [bt] [mid ]; A [bt] = a [bt] ^ a [mid];}} / ** * Fast row to find the benchmark point position * * @param a * @param bt * @param eds * @Return * / Private Static int pivotpartition (int a [], int Bt, int ED) {// Take the intermediate value as stand to prevent the array in an orderly appearance O (n^2) Swapvar (a, bt, ed); int Stand = a [bt] ; While (BT <ED) {While (BT <ED && A [ED]> = Stand) {ED-;} if (bt <ed) {a [bt ++] = a [ed];} While (bt < ED && A [BT] <= Stand) {bt ++;} if (bt <ed) {a [eds ---] = a [bt];} a [bt] = stand; return bt;} /****** Heap sort (from small to large) * * * @param a * @param n */ public static void heapsort (int a [], int n) {int TMP; // Construct a large pile of builtmaxheap (a, n); for (int j = n-1; j> = 1; j-) {tmp = a [0]; a [0] = a [j]; a [j] = tmp; maxheapify (a, 0, j);} } / ** * Construct a lot of roots * * * @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);} / ** * Maintenance The maximum pile of maintenance starting from the bid I * * * * @Param A * @param N * / Private Static void Maxheapify ( int a [], int i, int n) {int left, right, local; space (i <n) {left = 2 * i + 1; right = 2 * i + 2; log = i; n && a [left]> a [i]) {i = left;} if (right <n && a [right]> a [i]) {i = right;} if (loc! = i) {a [a) i] = a [loc] ^ a [i]; a [loc] = a [loc] ^ a [i]; a [i] = a [loc] ^ a [i];} else {break;}}}} } / ** * Select Sorting directly * * * @param a * @param n * / Public Static Void SELECTSORT (int a [], int n) {int i, j, local; for (i = 0; i <n; i ++) {loc = i; for (j = i+1; j <n; j ++) {if (a [j] <a [loc]) {loc = j;}} if (loc! = i) {a) {a) [i] = a [i] ^ a [loc]; a [loc] = a [i] ^ a [loc]; a [i] = a [i] ^ a [loc];}} /** * Directly inserted sort * * * @param a * @param n */ Public Static void Insertsort (int a [], int n) {int i, j, tmp; for (i = 1; i <n; i ++) {TMP = A [i]; for (j = i-1; j> = 0; j-) {if (a [j]> tmp) {a [j + 1] = a [j];} else {break ;}} A [j + 1] = tmp;} / ** * bubbling sort * * * @param a * @param n * / public static void bubblesort (int a [], int n) {int i, j ; for (i = 0; i <n -1; i ++) {for (j = 0; j <n -i -1; j ++) {if (a [j]> a [j+1]) {a [a [a j] = a [j] ^ a [j + 1]; a [j + 1] = a [j] ^ a [j + 1]; a [j] = a [j] ^ a [j + 1] ;}}}} / ** * Print array * * @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]);}}}}}