Die Schnellsortiermethode verwendet hauptsächlich Arrays.sort (), um sie zu implementieren.
Die Blasenmethode besteht darin, Traversal -Arrays zu vergleichen und die minimalen oder maximalen Werte durch einen kontinuierlichen Vergleich einzeln zu durchqueren.
Die Auswahlsortierungsmethode besteht darin, die ersten Daten des Arrays als größten oder kleinsten Wert zu verwenden und dann ein geordnetes Array über eine Vergleichsschleife auszugeben.
Das Einfügen von Sortieren besteht darin, die Daten in einem Array auszuwählen und sie am Ende zu sortieren, indem sie ständig einfügen und vergleichen.
Die Codekopie lautet wie folgt:
Paket com.firewolf.sort;
öffentliche Klasse 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 ("Sortierergebnis einfügen:");
Mysort.printarray (Array);
System.out.println ();
Mysort.Bubblesort (Array);
System.out.print ("Blasensortgebnis:");
Mysort.printarray (Array);
Mysort.qSort (Array);
System.out.println ();
System.out.print ("Quick Sort -Ergebnis:");
Mysort.printarray (Array);
Mysort.Shellsort (Array);
System.out.println ();
System.out.print ("Hill Sort -Ergebnis:");
Mysort.printarray (Array);
Mysort.SelectSort (Array);
System.out.println ();
System.out.print ("Sortierenergebnis auswählen:");
Mysort.printarray (Array);
}
/**
* Direkteinfügungssortieren
* Grundidee: In der zu sortierenden Zahlen, unter der Annahme, dass die vorherigen (n-1) [n> = 2] Zahlen bereits in Ordnung sind . Dies macht diese N -Zahlen auch in Ordnung. Wiederholen Sie diesen Zyklus, bis alle in der Reihenfolge angeordnet sind
*/
public void InsertSort (int [] Array) {
int temp = 0;
für (int i = 1; i <array.length; i ++) {
int j = i-1;
temp = array [i];
für (; j> = 0 && temp <array [j]; j-) {
Array [j+1] = Array [j];
}
Array [j+1] = temp;
}
}
/**
* Bubble -Sortierung
* Grundidee: In den zu sortierenden Zahlen, vergleichen und passen Sie die beiden benachbarten Zahlen von oben nach unten, um größere Zahlen zum Versinken zu erzielen, kleinere. Das heißt, wenn zwei benachbarte Zahlen verglichen werden und festgestellt werden, dass ihre Sortierung den Sortieranforderungen entgegengesetzt ist, werden sie austauscht.
*/
public void bubblesort (int [] array) {
int temp;
für (int i = 0; i <array.length; i ++) {// Anzahl der Reisen
für (int j = 0; j <array.length-i-1; j ++) {// Anzahl der Vergleiche
if (Array [j]> Array [j+1]) {
temp = array [j];
Array [j] = Array [j+1];
Array [j+1] = temp;
}
}
}
}
/**
* Schnelle Sortierung
* Grundidee: Wählen Sie ein Benchmark -Element aus, normalerweise das erste Element oder das letzte Element, und teilen Sie durch einen Scan die zu sortierte Sequenz in zwei Teile. Benchmarkelement.
* @param Array
*/
public void Qsort (int array []) {
if (array.length> 1) {
_qsort (Array, 0, Array.Length-1);
}
}
/**
* Schnelles Sortieren für eine Reise
* @param Array
*/
private void _qsort (int [] Array, int niedrig, int hoch) {
if (niedrig <hoch) {
int Middle = getMiddle (Array, niedrig, hoch);
_qsort (Array, niedrig, Mitte-1);
_qsort (Array, Mitte+1, hoch);
}
}
/**
* Holen Sie sich den Zwischenwert
*/
Private int getMiddle (int [] Array, int niedrig, int hoch) {
int tmp = array [niedrig];
while (niedrig <hoch) {
while (niedrig <hoch && array [hoch]> = tmp)
Hoch--;
Array [niedrig] = Array [hoch];
while (niedrig <hoch && array [niedrig] <= tmp)
niedrig ++;
Array [hoch] = Array [niedrig];
}
Array [niedrig] = TMP;
niedrig zurückkehren;
}
/**
* Einfache Sortierung der Auswahl
* Grundidee: Wählen Sie unter den zu sortierenden Zahlen die kleinste Zahl aus und tauschen Sie sie mit der Nummer in der ersten Position aus. Weg, bis die vorletzte Zahl mit der letzten Zahl verglichen wird.
* @param Array
*/
public void selectSort (int [] Array) {
int Position = 0;
für (int i = 0; i <array.length; i ++) {
int j = i+1;
Position = i;
int temp = array [i];
für (; j <array.length; j ++) {
if (Array [j] <temp) {
temp = array [j];
Position = j;
}
}
Array [Position] = Array [i];
Array [i] = temp;
}
}
/**
* Hill Sort (minimale inkrementelle Sortierung)
* Grundidee: Der Algorithmus teilt zunächst die Anzahl, die in mehreren Gruppen sortiert werden soll, gemäß einem bestimmten Inkrement D (N/2, n ist die Anzahl der zu sortierten Zahlen) und die in jeder Gruppe aufgezeichneten Indexs unterscheiden sich von d. Für jede Gruppe werden alle Elemente direkt sortiert, dann mit einem kleineren Inkrement (d/2) und dann direkt in jeder Gruppe sortiert. Wenn das Inkrement auf 1 reduziert wird, wird die Sortierung nach der Durchführung der direkten Einfügungssortierung abgeschlossen.
* @param Array
*/
public void Shellsort (int [] Array) {
double d1 = array.length;
int temp = 0;
while (wahr) {
d1 = math.ceil (d1/2);
int d = (int) d1;
für (int x = 0; x <d; x ++) {
für (int i = x+d; i <array.length; i+= d) {
int j = id;
temp = array [i];
für (; j> = 0 && temp <array [j]; j- = d) {
Array [j+d] = array [j];
}
Array [j+d] = temp;
}
}
if (d == 1)
brechen;
}
}
/**
* Drucken Sie alle Elemente im Array aus
*/
public void printArray (int [] Array) {
für (int i = 0; i <array.length; i ++) {
System.out.print (Array [i]+"");
}
}
}
Hier sind einige Beispiele für die separat verwendete Sortiermethoden
Schnellsortieren mit der Sortiermethode mit Arrays
Die Codekopie lautet wie folgt:
Import Java.util.Arrays;
public class test2 {
public static void main (String [] args) {
int [] a = {5,4,2,4,9,1};
Arrays.Sort (a); // sortieren
für (int i: a) {
System.out.print (i);
}
}
}
Blasensortieralgorithmus
Die Codekopie lautet wie folgt:
public static int [] bubblesort (int [] args) {// Blasensortieralgorithmus
für (int i = 0; i <argsgth-1; i ++) {
für (int j = i+1; j <argsgth; j ++) {
if (args [i]> args [j]) {
int temp = args [i];
args [i] = args [j];
args [j] = temp;
}
}
}
Rückkehr Args;
}
Wählen Sie den Sortieralgorithmus aus
Die Codekopie lautet wie folgt:
public static int [] selectSort (int [] args) {// Sortieralgorithmus auswählen
für (int i = 0; i <argsgth-1; i ++) {
int min = i;
für (int j = i+1; j <argsgth; j ++) {
if (args [min]> args [j]) {
min = j;
}
}
if (min! = i) {
int temp = args [i];
args [i] = args [min];
args [min] = temp;
}
}
Rückkehr Args;
}
Sortieralgorithmus einfügen
Die Codekopie lautet wie folgt:
public static int [] InsertSort (int [] args) {// Sortieralgorithmus einfügen
für (int i = 1; i <args.length; i ++) {
für (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;
} sonst brechen;
}
}
Rückkehr Args;
}
Die oben genannten sind vier Sortiermethoden in Java. Unterschiedliche Methoden haben unterschiedliche Effizienz.
Blasensorte: Vergleich O (N2) Datenaustausch O (N2)
Wählen Sie Sortieren: Vergleiche O (N2) Datenaustausch O (n)
Sortier einfügen: Vergleiche O (N2) Kopieren Sie die Daten o (n)
In praktischen Anwendungen sollten wir versuchen, effiziente Algorithmen zu wählen.