Die Verwendung von Goroutine zum Vergleichen zweier Bäume in Golang ist gleichwertig

Der PHP-Editor Banana stellte vor, dass Golang eine leistungsstarke Programmiersprache ist und Goroutine eines ihrer wichtigen Merkmale der gleichzeitigen Programmierung ist. In Golang müssen wir oft die Äquivalenz zweier Bäume vergleichen, das heißt, um festzustellen, ob zwei Bäume die gleiche Struktur und den gleichen Wert haben. Die Verwendung von Goroutine zur Durchführung von Baumvergleichsvorgängen kann die Programmeffizienz und die Parallelitätsleistung verbessern. Durch die parallele Durchführung eines rekursiven Vergleichs der Knoten zweier Bäume kann die Vergleichszeit erheblich verkürzt werden. Diese Methode ist nicht nur einfach und effizient, sondern auch leicht zu verstehen und umzusetzen. Daher ist die Verwendung von Goroutine zum Vergleich zweier Bäume in Golang ein empfohlener Ansatz.

Frageninhalt

Ohne die Verwendung von Kanälen kann ich zwei Bäume vergleichen, um zu sehen, ob sie gleichwertig sind, aber mit Kanälen kann ich nicht herausfinden, wie das geht.

Dies ist ein Beispielcode, den ich mithilfe von Kanälen geschrieben habe.

func Walk(t *Tree, ch chan int) {
    if t == nil {
        return
    }
    Walk(t.Left, ch)
    ch <- t.Value
    Walk(t.Right, ch)
}

func Same(t1, t2 *Tree) bool {

    t1Ch := make(chan int)
    t2Ch := make(chan int)

    Walk(t1, t1Ch)
    Walk(t2, t2Ch)
    output := make(chan bool)
    go func() {
        n1 := <-t1Ch
        n2 := <-t2Ch
        output <- n1 == n2
    }()
    return <-output

}

func main() {
    fmt.Println((&root, &root1))
}

Hinweis: Die vollständige Beschreibung finden Sie hier https://go.dev/tour/concurrency/7

Workaround

Zunächst sollten Sie den Kanal schließen, nachdem Sie den Baum durchlaufen haben. Dies kann durch Abtrennen der rekursiven Funktion wie folgt erfolgen:

func walk(t *tree.tree, ch chan int) {
    defer close(ch)
    if t != nil {
        ch <- t.value
        walkrecursively(t.left, ch)
        walkrecursively(t.right, ch)
    }
    
}

func walkrecursively(t *tree.tree, ch chan int) {
    if t != nil {
        ch <- t.value
        walkrecursively(t.left, ch)
        walkrecursively(t.right, ch)
    }
}

Jetzt kann Ihre Funktion same() beide Kanäle abdecken und weiß, wann die Arbeit erledigt ist:

func same(t1, t2 *tree.tree) bool {

    // two channels for walking over two trees
    ch1 := make(chan int)
    ch2 := make(chan int)
    
    // two integer slices to capture two results
    sequence1 := []int{}
    sequence2 := []int{}
    
    // two go routines to push values to the channels
    // important! these must be go routines
    go walk(t1, ch1)
    go walk(t2, ch2)
    
    // range over the channels to populate the sequence vars
    for n1 := range ch1 {
        sequence1 = append(sequence1, n1)   
    }
    for n2 := range ch2 {
        sequence2 = append(sequence2, n2)   
    }

    // since trees are randomly structured, we sort
    sort.ints(sequence1)
    sort.ints(sequence2)

    // slicesareequal is a helper function
    return slicesareequal(sequence1, sequence2)
}

Ihre Hilfsfunktion könnte so aussehen:

func slicesAreEqual(a, b []int) bool {
    if len(a) != len(b) {
        return false
    }
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

Das obige ist der detaillierte Inhalt vonDie Verwendung von Goroutine zum Vergleichen zweier Bäume in Golang ist gleichwertig. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!