La méthode de tri rapide utilise principalement des arrays.sort () pour l'implémenter.
La méthode de la bulle consiste à utiliser des tableaux de traversée pour comparer et à traverser les valeurs minimales ou maximales une par une par comparaison continue.
La méthode de tri de sélection consiste à utiliser les premières données du tableau comme la plus grande ou la plus petite valeur, puis à sortir un tableau ordonné via une boucle de comparaison.
Le tri des insert consiste à sélectionner les données dans un tableau et à le trier en fin de compte en les insérant et en la comparant constamment.
La copie de code est la suivante:
Package com.firewolf.sort;
classe publique MySort {
/ **
* @param args
* /
public static void main (String [] args) {
int array [] = {45,32,54,12,43,65,11,3,43,6,33,90,44,1,178};
Mysort mysort = new mysort ();
mysort.insertsort (array);
System.out.print ("Résultat de tri inséré:");
MySort.printArray (Array);
System.out.println ();
mysort.bubblesort (array);
System.out.print ("Résultat de tri de bulles:");
MySort.printArray (Array);
mysort.qsort (array);
System.out.println ();
System.out.print ("Résultat rapide:");
MySort.printArray (Array);
mysort.shellort (array);
System.out.println ();
System.out.print ("Résultat du tri des collines:");
MySort.printArray (Array);
MySort.SelectSort (Array);
System.out.println ();
System.out.print ("SELECT SORT Result:");
MySort.printArray (Array);
}
/ **
* Tri d'insertion directe
* Idée de base: dans l'ensemble des nombres à tri, en supposant que les nombres précédents (n-1) [n> = 2] sont déjà en ordre, vous devez maintenant insérer le numéro le nième dans le numéro ordonné dans l'ordre précédent . Répétez ce cycle jusqu'à ce que tous soient disposés dans l'ordre
* /
insertsort public public (array int []) {
int temp = 0;
pour (int i = 1; i <array.length; i ++) {
int j = i-1;
temp = array [i];
pour (; j> = 0 && temp <array [j]; j -) {
Array [J + 1] = Array [J];
}
Array [J + 1] = temp;
}
}
/ **
* Toi à bulles
* Idée de base: dans l'ensemble des nombres à tri, comparer et ajuster les deux nombres adjacents de haut en bas pour faire des nombres plus gros pour couler, les plus petits augmentent. Autrement dit, chaque fois que deux nombres adjacents sont comparés et ont constaté que leur tri est opposé aux exigences de tri, ils sont échangés.
* /
public void bubblesort (int [] array) {
int temp;
for (int i = 0; i <array.length; i ++) {// nombre de voyages
pour (int j = 0; j <array.length-i-1; j ++) {// nombre de comparaisons
if (array [j]> array [j + 1]) {
temp = array [j];
Array [J] = Array [J + 1];
Array [J + 1] = temp;
}
}
}
}
/ **
* Sort rapide
* Idée de base: sélectionnez un élément de référence, généralement le premier élément ou le dernier élément, et à travers un scan, divisez la séquence à tri en deux parties. Élément de référence.
* Array @param
* /
public void qsort (int array []) {
if (array.length> 1) {
_qsort (array, 0, array.length-1);
}
}
/ **
* Tri rapide pour un voyage
* Array @param
* /
private void _qsort (int [] array, int low, int high) {
if (bas <high) {
int middle = getmiddle (tableau, bas, haut);
_qsort (tableau, bas, milieu-1);
_qsort (tableau, milieu + 1, haut);
}
}
/ **
* Obtenez la valeur intermédiaire
* /
private int getmiddle (int [] array, int low, int high) {
int tmp = array [bas];
tandis que (bas <high) {
tandis que (basse <high && array [high]> = tmp)
Haut--;
Array [Low] = Array [High];
tandis que (basse <high && tableau [bas] <= tmp)
faible ++;
Array [High] = Array [Low];
}
Array [bas] = TMP;
retour bas;
}
/ **
* Sing de sélection simple
* Idée de base: parmi l'ensemble des nombres à tri, sélectionnez le plus petit nombre et échangez-le avec le nombre en première position; moyen jusqu'à ce que l'avant-dernier nombre soit comparé au dernier numéro.
* Array @param
* /
public void seletsort (int [] array) {
position int = 0;
for (int i = 0; i <array.length; i ++) {
int j = i + 1;
position = i;
int temp = array [i];
pour (; j <array.length; j ++) {
if (array [j] <temp) {
temp = array [j];
position = j;
}
}
array [position] = array [i];
Array [i] = temp;
}
}
/ **
* Sort de colline (tri incrémental minimum)
* Idée de base: l'algorithme divise d'abord le nombre à tri en plusieurs groupes en fonction d'une certaine incrément D (n / 2, n est le nombre de nombres à tri), et les indices enregistrés dans chaque groupe sont différents de d. Pour chaque groupe, tous les éléments sont triés directement, puis regroupés avec un incrément plus petit (D / 2), puis triés directement dans chaque groupe. Lorsque l'incrément est réduit à 1, le tri est terminé une fois le tri d'insertion direct effectué.
* Array @param
* /
public void shellort (int [] array) {
double d1 = array.length;
int temp = 0;
while (true) {
d1 = math.ceil (d1 / 2);
int d = (int) d1;
pour (int x = 0; x <d; x ++) {
pour (int i = x + d; i <array.length; i + = d) {
int j = id;
temp = array [i];
pour (; j> = 0 && temp <array [j]; j- = d) {
array [j + d] = array [j];
}
array [j + d] = temp;
}
}
si (d == 1)
casser;
}
}
/ **
* Imprimez tous les éléments du tableau
* /
public void PrintArray (int [] array) {
for (int i = 0; i <array.length; i ++) {
System.out.print (array [i] + "");
}
}
}
Voici quelques exemples de méthodes de tri utilisées séparément
Tri rapide en utilisant la méthode de tri avec les tableaux
La copie de code est la suivante:
import java.util.arrays;
classe publique test2 {
public static void main (String [] args) {
int [] a = {5,4,2,4,9,1};
Arrays.sort (a);
pour (int i: a) {
System.out.print (i);
}
}
}
Algorithme de tri à bulles
La copie de code est la suivante:
public static int [] bubblesort (int [] args) {// algorithme de tri de bulles
for (int i = 0; i <args.length-1; i ++) {
pour (int j = i + 1; j <args.length; j ++) {
if (args [i]> args [j]) {
int temp = args [i];
args [i] = args [j];
args [j] = temp;
}
}
}
retour args;
}
Sélectionnez l'algorithme de tri
La copie de code est la suivante:
public static int [] selectSort (int [] args) {// sélectionner l'algorithme de tri
for (int i = 0; i <args.length-1; i ++) {
int min = i;
pour (int j = i + 1; j <args.length; j ++) {
if (args [min]> args [j]) {
min = j;
}
}
si (min! = i) {
int temp = args [i];
args [i] = args [min];
args [min] = temp;
}
}
retour args;
}
Algorithme de tri inséré
La copie de code est la suivante:
public static int [] insertsort (int [] args) {// insérer un algorithme de tri
pour (int i = 1; i <args.length; i ++) {
pour (int j = i; j> 0; j -) {
if (args [j] <args [j-1]) {
int temp = args [j-1];
args [j-1] = args [j];
args [j] = temp;
} else se briser;
}
}
retour args;
}
Ce qui précède est quatre méthodes de tri en Java. Différentes méthodes ont des efficacités différentes.
Tri de bulles: comparaison O (N2) Échange de données O (N2)
Sélectionner le tri: comparer O (N2) Exchange de données O (n)
Tri d'insertion: Comparez O (N2) Copier les données O (N)
Dans les applications pratiques, nous devons essayer de choisir des algorithmes efficaces.