Anleitung zum direkten Sortieralgorithmus Funktioniert mit einer Java-Implementierung

1. Einleitung

In diesem Tutorial erklären wir, wie der In-Place-Sortieralgorithmus funktioniert.

2. In-Place-Algorithmen

Die In-Place-Algorithmen sind solche, die keine Hilfsdatenstruktur benötigen, um die Eingabedaten zu transformieren. Grundsätzlich bedeutet dies, dass der Algorithmus keinen zusätzlichen Speicherplatz für die Eingabemanipulation verwendet. Es überschreibt praktisch die Eingabe mit der Ausgabe.

In der Realität kann der Algorithmus jedoch tatsächlich einen kleinen und nicht konstanten zusätzlichen Platz für Hilfsvariablen benötigen. Die Komplexität dieses Raums ist in den meisten Fällen O (log n) , obwohl manchmal alles andere als linear zulässig ist.

3. Pseudocode

Lassen Sie uns nun einen Pseudocode sehen und den In-Place-Algorithmus mit dem Out-of-Place-Algorithmus vergleichen.

Wir gehen davon aus, dass wir ein Array von n Zahlen umkehren wollen .

3.1. In-Place-Algorithmus

Wenn wir über das Problem nachdenken, werden wir sehen, dass wir ein Eingabearray und ein umgekehrtes Array als Ausgabe haben. Am Ende brauchen wir nicht unser ursprüngliches Array, sondern nur das umgekehrte.

Warum sollten wir dann die Eingabe nicht überschreiben, anstatt ihre Werte in das völlig neue Array zu verschieben, da dies möglicherweise eine sehr offensichtliche Methode ist? Dazu benötigen wir nur eine zusätzliche Variable , um die Werte, mit denen wir gerade arbeiten, vorübergehend zu speichern:

reversInPlace(array A[n]) for i from 0 to n/2 temp = A[i] A[i] = A[n - 1 - i] A[n - 1 - i] = temp

Es ist bemerkenswert zu erwähnen, dass der zusätzliche Platz, den wir benötigen, in diesem Fall immer O (1) ist, egal wie groß das Array ist .

Die Abbildung zeigt, dass wir weniger Schritte benötigen als im vorherigen Fall:

3.2. Out-of-Place-Algorithmus

Auf der anderen Seite können wir dies auch auf eine ziemlich einfache, offensichtlichere Weise tun. Wir können ein neues Array derselben Größe erstellen, die Werte aus dem Original in der entsprechenden Reihenfolge kopieren und dann das Originalarray löschen:

reverseOutOfPlace(array A[n]) create new array B[n] for i from 0 to n - 1 B[i] = A[i] delete A return B

Dies wird zwar das tun, was wir wollten, aber es ist nicht effizient genug. Wir benötigen O (n) zusätzlichen Speicherplatz, da wir zwei Arrays zum Bearbeiten haben . Außerdem ist das Erstellen und Entfernen eines neuen Arrays normalerweise ein langsamer Vorgang.

Sehen wir uns die Illustration des Prozesses an:

4. Java-Implementierung

Lassen Sie uns nun sehen, wie wir das, was wir im vorherigen Abschnitt gelernt haben, in Java implementieren können.

Zunächst implementieren wir einen In-Place-Algorithmus:

public static int[] reverseInPlace(int A[]) { int n = A.length; for (int i = 0; i < n / 2; i++) { int temp = A[i]; A[i] = A[n - 1 - i]; A[n - 1 - i] = temp; } return A; }

Wir können leicht testen, ob dies wie erwartet funktioniert:

@Test public void givenArray_whenInPlaceSort_thenReversed() { int[] input = {1, 2, 3, 4, 5, 6, 7}; int[] expected = {7, 6, 5, 4, 3, 2, 1}; assertArrayEquals("the two arrays are not equal", expected, InOutSort.reverseInPlace(input)); }

Lassen Sie uns zweitens die Implementierung des Out-of-Place-Algorithmus überprüfen:

public static int[] reverseOutOfPlace(int A[]) { int n = A.length; int[] B = new int[n]; for (int i = 0; i < n; i++) { B[n - i - 1] = A[i]; } return B; }

Der Test ist ziemlich einfach:

@Test public void givenArray_whenOutOfPlaceSort_thenReversed() { int[] input = {1, 2, 3, 4, 5, 6, 7}; int[] expected = {7, 6, 5, 4, 3, 2, 1}; assertArrayEquals("the two arrays are not equal", expected, InOutSort.reverseOutOfPlace(input)); }

5. Beispiele

Es gibt viele Sortieralgorithmen, die einen direkten Ansatz verwenden. Einige davon sind Einfügesortierung, Blasensortierung, Heap-Sortierung, Quicksortierung und Shell-Sortierung. Sie können mehr über sie erfahren und ihre Java-Implementierungen überprüfen.

Außerdem müssen wir Kammsortierung und Heapsort erwähnen. Alle diese haben Raumkomplexität O (log n) .

Es kann auch nützlich sein, mehr über die Theorie der Big-O-Notation zu erfahren und einige praktische Java-Beispiele zur Komplexität des Algorithmus zu lesen.

6. Fazit

In diesem Artikel haben wir die sogenannten In-Place-Algorithmen beschrieben, ihre Funktionsweise mit Pseudocode veranschaulicht und einige Beispiele aufgeführt, einige Algorithmen aufgelistet, die nach diesem Prinzip arbeiten, und schließlich die grundlegenden Beispiele in Java implementiert.

Wie üblich konnte der gesamte Code auf GitHub gefunden werden.