Comment puis-je supprimer efficacement les éléments en double des tranches Go ?

Optimisation de la suppression des doublons dans Go Slices

Introduction

Les rencontres avec des ensembles de données contenant des éléments en double sont monnaie courante, en particulier dans les scénarios impliquant une collecte de données approfondie. La suppression de ces doublons pour obtenir des valeurs uniques est cruciale pour diverses opérations. En Go, pour y parvenir, il faut des algorithmes efficaces pour minimiser la complexité temporelle et spatiale. Cet article explore une solution complète pour supprimer les doublons des tranches de chaînes ou d'entiers.

Implémentation générique

La première approche exploite les génériques, disponibles dans Go v1.18 et versions ultérieures. , pour gérer des tranches de tout type comparable (T). Il utilise une carte pour suivre les valeurs rencontrées, garantissant que seuls les éléments uniques sont ajoutés à la tranche résultante.

func removeDuplicate[T comparable](sliceList []T) []T {
    allKeys := make(map[T]bool)
    list := []T{}
    for _, item := range sliceList {
        if _, value := allKeys[item]; !value {
            allKeys[item] = true
            list = append(list, item)
        }
    }
    return list
}

Optimisation spécifique aux chaînes

Pour les tranches contenant uniquement chaînes, il existe une solution plus optimisée utilisant la fonction make. Il initialise la carte avec la taille de la tranche d'entrée, éliminant ainsi le besoin de redimensionnement dynamique et les pénalités potentielles de performances.

func removeDuplicateStr(strSlice []string) []string {
    allKeys := make(map[string]bool, len(strSlice))
    list := []string{}
    for _, item := range strSlice {
        if _, value := allKeys[item]; !value {
            allKeys[item] = true
            list = append(list, item)
        }
    }
    return list
}

Optimisation spécifique aux entiers

Similaire à l'approche spécifique aux chaînes, une fonction spécialisée pour les tranches d'entiers peut exploiter la fonction make pour améliorer performances.

func removeDuplicateInt(intSlice []int) []int {
    allKeys := make(map[int]bool, len(intSlice))
    list := []int{}
    for _, item := range intSlice {
        if _, value := allKeys[item]; !value {
            allKeys[item] = true
            list = append(list, item)
        }
    }
    return list
}

Utilisation

Quel que soit le type de tranche, l'utilisation de ces fonctions reste simple. Passez simplement la tranche d'entrée comme argument et vous recevrez une tranche contenant uniquement les éléments uniques.

cities := []string{"Mumbai", "Delhi", "Ahmedabad", "Mumbai", "Bangalore", "Delhi", "Kolkata", "Pune"}
uniqueCities := removeDuplicate(cities)

fmt.Println(uniqueCities) // [Mumbai Delhi Ahmedabad Bangalore Kolkata Pune]

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!