Wie man Golang-Blubbern einordnet

Detaillierte Erklärung des Golang-Blasensortieralgorithmus

Blasensortierung ist ein gängiger Sortieralgorithmus. Sein Prinzip ist sehr einfach, es ist eine Art Austauschsortierung. Die Kernidee dieses Algorithmus besteht darin, die Größen zweier benachbarter Elemente zu vergleichen und dann ihre Positionen entsprechend der Größenbeziehung auszutauschen. In jeder Runde wird das größte oder kleinste Element an einem Ende der Sequenz angeordnet. Es gibt zwei spezifische Implementierungsmethoden: eine von vorne nach hinten und die andere von hinten nach vorne. In diesem Artikel wird die Implementierung der Blasensortierung in Golang vorgestellt.

Zuerst erstellen wir ein Integer-Array und übergeben die Bubble-Sort-Funktion:

package main

import "fmt"

func main() {
    arr := []int{3, 7, 1, 4, 2, 8, 5, 9, 6}
    fmt.Println("排序前:",arr)
    BubbleSort(arr)
    fmt.Println("排序后:",arr)
}

func BubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-1-i; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}

In der BubbleSort-Funktion ermitteln wir zunächst die Länge des Arrays und richten dann zwei Schleifenschachtelungen ein. Die äußere Schleife ist eine Schleife über das gesamte Array und die innere Schleife ist eine Schleife über die Elemente. In der inneren Schleife vergleichen wir die Größen benachbarter Elemente und tauschen dann ihre Positionen basierend auf dem Größenverhältnis.

Die Austauschmethode wird durch die Mehrfachzuweisung von Golang implementiert, nämlich „arr[j], arr[j+1] = arr[j+1], arr[j]“. Diese Anweisung weist arr[j] den Wert von arr[j+1] und arr[j+1] den Wert von arr[j] zu. Auf diese Weise kann der Austausch zwischen zwei Elementen abgeschlossen werden.

Es ist zu beachten, dass bei jeder Sortierrunde das kleinste oder größte Element an ein Ende der Sequenz verschoben wird. Um die Effizienz sicherzustellen, müssen wir die Anzahl der sortierten Elemente i in der äußeren Schleife subtrahieren, d. h. „for j := 0; j < n-1-i; j++“. Auf diese Weise umfasst die Anzahl der Vergleiche in jeder Sortierrunde keine Elemente, die bereits sortiert wurden.

Schließlich rufen wir die Funktion „BubbleSort“ in der Hauptfunktion auf und drucken die Array-Ergebnisse vor und nach der Sortierung auf der Konsole aus.

Als nächstes testen wir die Leistung dieses Algorithmus. Zum Testen können wir Golangs eigene Testbibliothek verwenden. Der spezifische Testcode lautet wie folgt:

package main

import (
    "testing"
)

func TestBubbleSort(t *testing.T) {
    arr := []int{3, 7, 1, 4, 2, 8, 5, 9, 6}
    BubbleSort(arr)
    if !checkSort(arr) {
        t.Error("BubbleSort test failed")
    }
}

func checkSort(arr []int) bool {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        if arr[i] > arr[i+1] {
            return false
        }
    }
    return true
}

In der Hauptfunktion definieren wir eine Funktion namens TestBubbleSort, mit der die Richtigkeit der von uns geschriebenen BubbleSort-Funktion getestet wird. In der Testfunktion rufen wir die Funktion BubbleSort auf und ermitteln mit der Funktion checkSort, ob das Sortierergebnis korrekt ist. Bei einem fehlerhaften Sortierergebnis wird die Fehlermeldung „BubbleSort-Test fehlgeschlagen“ ausgegeben.

Als nächstes verwenden wir den Befehl go test, um den Test auszuführen. Geben Sie in der Befehlszeile den folgenden Befehl ein:

go test -v -run="TestBubbleSort"

Dieser Befehl führt die TestBubbleSort-Funktion aus und gibt die Testergebnisse auf der Konsole aus. Die Ergebnisse sind wie folgt:

=== RUN   TestBubbleSort
--- PASS: TestBubbleSort (0.00s)
PASS
ok      _/home/go_ws/src/gotest/src/TestBubbleSort   0.097s

Wie aus den Testergebnissen ersichtlich ist, hat der Sortieralgorithmus den Komponententest bestanden und die Testzeit betrug nur 0,097 Sekunden. Daher schneidet der Blasensortierungsalgorithmus hinsichtlich der Effizienz gut ab.

Zusammenfassung

Dieser Artikel stellt die Implementierung der Blasensortierung in Golang vor und überprüft die Richtigkeit und Effizienz des Sortieralgorithmus durch Unit-Tests. In praktischen Anwendungen können wir diesen Algorithmus nach Bedarf entsprechend optimieren, um bessere Sortierergebnisse zu erzielen.

Das obige ist der detaillierte Inhalt vonWie man Golang-Blubbern einordnet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!