Utiliser goroutine pour comparer deux arbres dans Golang est équivalent

L'éditeur PHP Banana a présenté que Golang est un langage de programmation puissant et que la goroutine est l'une de ses fonctionnalités importantes de programmation simultanée. En Golang, nous avons souvent besoin de comparer l’équivalence de deux arbres, c’est-à-dire de déterminer si deux arbres ont la même structure et la même valeur. L'utilisation de goroutine pour effectuer des opérations de comparaison d'arbres peut améliorer l'efficacité du programme et les performances de concurrence. En effectuant une comparaison récursive des nœuds de deux arbres en parallèle, le temps de comparaison peut être considérablement réduit. Cette méthode est non seulement simple et efficace, mais aussi facile à comprendre et à mettre en œuvre. Par conséquent, utiliser goroutine pour comparer deux arbres dans Golang est une approche recommandée.

Contenu de la question

Sans utiliser de canaux, je peux comparer deux arbres pour voir s'ils sont équivalents, mais avec les canaux, je n'arrive pas à comprendre comment faire cela.

Ceci est un exemple de code que j'ai écrit en utilisant des canaux.

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))
}

Remarque : Vous pouvez trouver la description complète ici https://go.dev/tour/concurrency/7

Solution de contournement

Tout d'abord, vous devez fermer le canal après avoir fini de parcourir l'arbre. Cela peut être fait en détachant la fonction récursive comme suit :

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)
    }
}

Maintenant, votre fonction same() peut couvrir les deux canaux et savoir quand le travail est terminé :

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)
}

Votre fonction d'assistance pourrait ressembler à ceci :

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
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!