Maison >développement back-end >Golang >Comment trouver efficacement les éléments d'une tranche de chaîne qui ne se trouvent pas dans une autre ?

Comment trouver efficacement les éléments d'une tranche de chaîne qui ne se trouvent pas dans une autre ?

Patricia Arquette
Patricia Arquetteoriginal
2024-12-08 20:43:10140parcourir

How to Efficiently Find the Elements in One String Slice That Are Not in Another?

Trouver la distinction entre deux tranches de chaîne

Lorsqu'il s'agit de tranches de chaîne en programmation, il est souvent nécessaire de déterminer les différences entre deux ensembles. Considérons le scénario suivant :

slice1 := []string{"foo", "bar","hello"}
slice2 := []string{"foo", "bar"}

Notre objectif est d'identifier et de générer les éléments qui existent dans la tranche 1 mais pas dans la tranche2.

Utiliser une HashMap pour une recherche efficace

Pour calculer efficacement la différence, nous pouvons exploiter une carte Go. Maps in Go propose une recherche en temps constant (O(1)), ce qui nous permet de déterminer rapidement si un élément existe dans un ensemble.

Implémentation de la fonction de différence

Voici une implémentation de la fonction de différence à l'aide d'une carte :

// difference returns the elements in `a` that aren't in `b`.
func difference(a, b []string) []string {
    mb := make(map[string]struct{}, len(b))
    for _, x := range b {
        mb[x] = struct{}{}
    }
    var diff []string
    for _, x := range a {
        if _, found := mb[x]; !found {
            diff = append(diff, x)
        }
    }
    return diff
}

Décomposer les Fonction

  • Une carte mb est créée avec une capacité égale à la longueur de slice2. Cette carte stockera les éléments de slice2 sous forme de clés, créant ainsi un ensemble.
  • Nous parcourons slice2, en ajoutant chaque élément comme clé à mb.
  • Pour chaque élément de slice1, nous vérifions s'il existe sous forme de clé en Mo. Si ce n'est pas le cas, nous l'ajoutons à la tranche diff, qui contiendra les éléments uniques à la tranche 1.
  • Enfin, nous renvoyons la tranche diff comme résultat.

Cette implémentation a une complexité temporelle approximative de O(n), où n est la longueur maximale de slice1 et slice2. Son efficacité provient des opérations à temps constant effectuées par la carte, qui garantissent une recherche et une insertion rapides.

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!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn