TOC

Bubble Sort in Java

Bubble Sort in Java

1. Einführung

In diesem kurzen Artikel werden wir den Bubble Sort-Algorithmus im Detail untersuchen und uns dabei auf eine Java-Implementierung konzentrieren.

Dies ist einer der einfachsten Sortieralgorithmen. the core idea is tokeep swapping adjacent elements eines Arrays, wenn sie in einer falschen Reihenfolge sind, bis die Sammlung sortiert ist.

Kleine Elemente „sprudeln“ an die Spitze der Liste, wenn wir die Datenstruktur durchlaufen. Daher ist die Technik als Blasensortierung bekannt.

Da die Sortierung durch Vertauschen erfolgt, können wir sagen, dass sie eine direkte Sortierung durchführt.

Auchif two elements have same values, resulting data will have their order preserved - was es zu einer stabilen Sortierung macht.

2. Methodik

Wie bereits erwähnt, durchlaufen wir ein Array, um es zu sortieren, während wir benachbarte Elemente vergleichen und sie bei Bedarf austauschen. Für ein Array der Größen führen wirn-1 solcher Iterationen durch.

Nehmen wir ein Beispiel, um die Methodik zu verstehen. Wir möchten das Array in aufsteigender Reihenfolge sortieren:

4 2 1 6 3 5

Wir beginnen die erste Iteration mit dem Vergleich von 4 und 2; Sie sind definitiv nicht in der richtigen Reihenfolge. Ein Tausch würde ergeben:

[2 4] 1 6 3 5

Wiederholen Sie dies nun für 4 und 1:

2[14] 6 3 5

Wir machen das bis zum Ende:

2 1 [4 6] 3 5

2 1 4[36] 5

2 1 4 3[5 6]

Wie wir sehen können, haben wir am Ende der ersten Iteration das letzte Element an seiner richtigen Stelle. Jetzt müssen wir nur noch das gleiche Verfahren in weiteren Iterationen wiederholen. Ausgenommen, wir schließen die Elemente aus, die bereits sortiert sind.

In der zweiten Iteration durchlaufen wir das gesamte Array mit Ausnahme des letzten Elements. In ähnlicher Weise lassen wir für die dritte Iteration die letzten beiden Elemente weg. Im Allgemeinen iterieren wir für die k-te Iteration bis zum Indexn-k (ausgeschlossen). Am Ende der Iterationen vonn-1erhalten wir das sortierte Array.

Nachdem Sie die Technik verstanden haben, wollen wir uns mit der Implementierung befassen.

3. Implementierung

Implementieren wir die Sortierung für das Beispielarray, das wir mit dem Java 8-Ansatz besprochen haben: 

void bubbleSort(Integer[] arr) {
    int n = arr.length;
    IntStream.range(0, n - 1)
    .flatMap(i -> IntStream.range(1, n - i))
    .forEach(j -> {
        if (arr[j - 1] > arr[j]) {
            int temp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = temp;
            }
     });
}

Und ein kurzer JUnit-Test für den Algorithmus: 

@Test
public void whenSortedWithBubbleSort_thenGetSortedArray() {
    Integer[] array = { 2, 1, 4, 6, 3, 5 };
    Integer[] sortedArray = { 1, 2, 3, 4, 5, 6 };
    BubbleSort bubbleSort = new BubbleSort();
    bubbleSort.bubbleSort(array);

    assertArrayEquals(array, sortedArray);
}

4. Komplexität und Optimierung

Wie wir sehen können,for the average and the worst case,the time complexity isO(n^2).

Außerdem findenthe space complexity, selbst im schlimmsten Fall,is O(1) as Bubble sort algorithm doesn’t require any extra memory und die Sortierung im ursprünglichen Array statt.

Durch sorgfältige Analyse der Lösung können wir sehen, dassif no swaps are found in an iteration, we don’t need to iterate further.

Im Fall des zuvor diskutierten Beispiels erhalten wir nach der 2. Iteration:

1 2 3 4 5 6

In der dritten Iteration müssen wir kein Paar benachbarter Elemente austauschen. So können wir alle verbleibenden Iterationen überspringen.

Bei einem sortierten Array ist ein Austausch in der ersten Iteration selbst nicht erforderlich. Dies bedeutet, dass wir die Ausführung stoppen können. Dies ist das beste Szenario und dietime complexity of the algorithm is O(n).

Lassen Sie uns nun die optimierte Lösung implementieren. 

public void optimizedBubbleSort(Integer[] arr) {
    int i = 0, n = arr.length;
    boolean swapNeeded = true;
    while (i < n - 1 && swapNeeded) {
        swapNeeded = false;
        for (int j = 1; j < n - i; j++) {
            if (arr[j - 1] > arr[j]) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
                swapNeeded = true;
            }
        }
        if(!swapNeeded) {
            break;
        }
        i++;
    }
}

Überprüfen wir die Ausgabe für den optimierten Algorithmus: 

@Test
public void
  givenIntegerArray_whenSortedWithOptimizedBubbleSort_thenGetSortedArray() {
      Integer[] array = { 2, 1, 4, 6, 3, 5 };
      Integer[] sortedArray = { 1, 2, 3, 4, 5, 6 };
      BubbleSort bubbleSort = new BubbleSort();
      bubbleSort.optimizedBubbleSort(array);

      assertArrayEquals(array, sortedArray);
}

5. Fazit

In diesem Tutorial haben wir gesehen, wie Bubble Sort funktioniert und wie es in Java implementiert wird. Wir haben auch gesehen, wie es optimiert werden kann. Zusammenfassend ist es ein an Ort und Stelle stabiler Algorithmus mit zeitlicher Komplexität:

  • Schlimmster und durchschnittlicher Fall: O (n * n), wenn das Array in umgekehrter Reihenfolge vorliegt

  • Bester Fall: O (n), wenn das Array bereits sortiert ist

Der Algorithmus ist in der Computergrafik beliebt, da er einige kleine Sortierfehler erkennen kann. Beispielsweise müssen in einem fast sortierten Array nur zwei Elemente ausgetauscht werden, um ein vollständig sortiertes Array zu erhalten. Bubble Sort kann solche Fehler beheben (d. H. sortiere dieses Array in linearer Zeit.

Wie immer kann der Code für die Implementierung dieses Algorithmusover on GitHub gefunden werden.

Related