GO n'a pas de type de collecte intégré, mais il peut être implémenté efficacement via des cartes. Utiliser la carte [t] struct {} Pour stocker les touches d'élément, les structures vides n'ont aucune surcharge de mémoire et la mise en ?uvre de l'addition, de l'inspection, de la suppression et d'autres opérations sont O (1) complexité temporelle; Dans un environnement simultané, Sync.RwMutex ou Sync.MAP peut être combiné pour assurer la sécurité des filetages; En termes de performances, d'utilisation de la mémoire, de co?t et de désordre de hachage; Il est recommandé d'encapsuler ADD, supprimer, contient, taille et autres méthodes pour simuler le comportement de collecte standard.

Dans GO, il n'y a pas de structure de données de set intégrée comme dans Python ou JavaScript, mais l'implémentation d'un efficacement est simple à l'aide d'une carte. L'idée clé est d'utiliser les clés d'une carte pour représenter les éléments définis et d'ignorer les valeurs (ou de les utiliser comme espaces réservées).

Voici comment vous pouvez le faire efficacement.

Utilisez une carte avec des valeurs de structure vides

La fa?on la plus courante et la plus économe en mémoire d'implémenter un ensemble dans GO consiste à utiliser une map[T]struct{} où T est le type de vos éléments.

Pourquoi struct{} ? Parce qu'il prend zéro mémoire lorsqu'il est stocké comme une valeur dans une carte, ce qui rend cette approche plus efficace que l'utilisation bool ou d'autres types.

 set: = make (map [int] struct {})

Pour ajouter un élément:

 set [5] = struct {} {}

Pour vérifier si un élément existe:

 Si _, existe: = set [5]; existe {
    // faire quelque chose
}

Cette méthode maintient l'utilisation de la mémoire faible et les opérations rapidement - toutes les opérations de base de set (insérer, supprimer, rechercher) sont une complexité temporelle O (1).

Gérer la sécurité des filetages pour une utilisation simultanée

Si vous travaillez dans un environnement simultané (par exemple, plusieurs Goroutines accédant à l'ensemble), les cartes standard ne sont pas s?res pour les lectures et les écritures simultanées.

Vous avez deux options principales:

• Enveloppez votre carte avec une sync.RWMutex pour contr?ler l'accès.
• Utilisez sync.Map si votre charge de travail implique principalement des insertions et des apparence avec quelques suppressions, bien que ce ne soit pas toujours le mieux adapté.

L'utilisation d'un wrapper basé sur Mutex ressemble à ceci:

 type set struct {
    m map [int] struct {}
    mu sync.rwmutex
}

func (s * set) add (val int) {
    s.mu.lock ()
    différer s.mu.unlock ()
    sm [val] = struct {} {}
}

func (s * set) contient (val int) bool {
    s.mu.rlock ()
    différer s.mu.runlock ()
    _, existe: = sm [val]
    Le retour existe
}

Pour une utilisation unique ou des charges de travail lourdes en lecture, restez avec une carte ordinaire - c'est plus rapide et plus simple.

Envisagez des compromis de performance

Bien que l'approche basée sur la carte soit simple et rapide, il existe quelques considérations liées aux performances:

• Surcharge de mémoire : les cartes stockent à la fois les touches et les valeurs, donc même si struct{} n'ajoute rien, la clé elle-même contribue toujours à l'utilisation de la mémoire.
• Co?t de hachage : chaque opération nécessite de hachage de la clé, donc si vous stockez de grandes structures comme des clés (pas communes), envisagez de les envelopper dans un pointeur ou de les aplatir.
• Ordre d'itération : les ensembles implémentés via les cartes ne conservent aucune commande. Si vous avez besoin d'une traversée commandée, vous devrez collecter les clés en tranche et les trier manuellement.

Si vous avez affaire à des entiers et que les performances sont essentielles, certaines personnes utilisent des implémentations bitset pour des gammes entières denses. Mais ceux-ci sont moins flexibles et ne conviennent pas aux ensembles clairsemés ou non en entegments.

Bonus: opérations de base que vous voudrez mettre en ?uvre

Voici quelques fonctions d'assistance que vous voudrez peut-être écrire pour votre ensemble:

• Ajouter : insérer un nouvel élément
• Supprimer : supprimer un élément existant
• Contient : le chèque existe
• Taille : numéro de retour d'éléments
• Clear : réinitialisez l'ensemble
• Articles : Obtenez une tranche de tous les articles (facultatif)

 func (s * set) retirer (val int) {
    s.mu.lock ()
    différer s.mu.unlock ()
    supprimer (sm, val)
}

func (s * set) size () int {
    Retour Len (SM)
}

Ces extensions aident à imiter le comportement de l'ensemble typique trouvé dans d'autres langues.

C'est essentiellement ?a - Go n'a pas un ensemble natif, mais l'utilisation d'une carte vous donne une alternative propre et effectuée. Il est assez simple pour la plupart des cas d'utilisation et facile à personnaliser en cas de besoin.

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!