Le package de tri de bibliothèque standard Go fournit des outils de tri efficaces et flexibles. Tout d'abord, il a une prise en charge de tri intégrée pour les tranches de type de base telles que les entiers, les numéros de points flottants et les cha?nes, en utilisant les fonctions tri.ints (), tri.float64s () et tri.strings () pour le tri des commandes ascendante; Deuxièmement, pour les structures ou lorsque des règles de tri personnalisées sont nécessaires, vous pouvez utiliser la fonction tri.slice () et fournir une fonction de comparaison, telle que le tri selon les champs de structure; Enfin, si un contr?le plus complexe est requis, vous pouvez personnaliser la logique de tri en implémentant l'interface tri. Interface (y compris les méthodes Len (), moins () et swap ()). De plus, toutes les opérations de tri sont effectuées en place, la modification des données d'origine, et l'algorithme sous-jacent combine le tri rapide et le tri des tas pour optimiser les performances.

Le package sort de la bibliothèque standard Go fournit des outils efficaces et flexibles pour le tri des données. Il est livré avec une prise en charge intégrée pour le tri des tranches de types de base comme les entiers, les flotteurs et les cha?nes, et vous permet également de définir la logique de tri personnalisée pour vos propres structures de données.

Tri intégré pour les types de base

Si vous travaillez avec des tranches de types communs tels que []int , []float64 ou []string , le package sort offre des fonctions prêtes à l'emploi:

• sort.Ints()
• sort.Float64s()
• sort.Strings()

Ces fonctions trient la tranche en place - ce qui signifie qu'elles modifient directement la tranche d'origine.

Par exemple:

 num: = [] int {5, 2, 6, 3}
tri.ints (num)
// nums est maintenant [2, 3, 5, 6]

Ils sont simples et assez rapides pour la plupart des cas d'utilisation de base où l'ordre croissant est souhaité.

Utilisation de Sort.slice pour le tri personnalisé

Lorsque vous traitez avec des tranches de structures ou lorsque vous avez besoin d'un ordre de tri personnalisé (comme descendant), la fonction sort.Slice() devient utile. Vous passez dans la tranche et une fonction de comparaison qui définit l'ordre.

Par exemple, si vous avez une liste d'utilisateurs et que vous souhaitez les trier par age:

 Tapez user struct {
    Cha?ne de noms
    ?ge int
}

utilisateurs: = [] utilisateur {
    {"Alice", 30},
    {"Bob", 25},
    {"Eve", 30},
}

Sort.slice (utilisateurs, func (i, j int) bool {
    retourner les utilisateurs [i] .age <utilisateurs [j] .age
})

Cela triera la tranche des users par age dans l'ordre croissant. Si deux utilisateurs ont le même age, leur commande d'origine est préservée (c'est ce qu'on appelle le tri stable).

Vous pouvez également modifier la condition pour trier dans l'ordre descendant:

 retourner les utilisateurs [i] .age> utilisateurs [j] .age

Implémentation de tri.interface pour plus de contr?le

Pour des scénarios plus complexes - en particulier lorsque vous travaillez avec des types de conteneurs personnalisés - vous souhaiterez peut-être implémenter l'interface sort.Interface . Interface. Cela implique de définir trois méthodes:

• Len() int
• Less(i, j int) bool
• Swap(i, j int)

Une fois que votre type a mis en ?uvre cette interface, vous pouvez appeler sort.Sort(yourType) pour le trier.

Voici comment vous pourriez le faire avec une tranche de structures personnalisée:

 Type Byage [] utilisateur

func (a byage) len () int {return len (a)}
func (a byage) moins (i, j int) bool {return a [i] .age <a [j] .age}
func (a byage) swap (i, j int) {a [i], a [j] = a [j], a [i]}

// utilisation
Sort.sort (Byage (utilisateurs))

Cette méthode vous donne un contr?le total sur le processus de tri et peut être plus réutilisable dans les programmes plus importants.

Quelques notes sur les performances et le comportement

• Toutes les fonctions du package sort effectuent le tri en place.
• L'algorithme sous-jacent est un hybride de Quicksort pour les petits ensembles de données et les optimisations Heapsort / PDQSort en fonction des données, donc les performances sont généralement solides.
• Si vous souhaitez une copie des données d'origine après le tri, assurez-vous de dupliquer la tranche avant de les tri.

N'oubliez pas non plus que sort.Slice() est généralement suffisant, sauf si vous devez réutiliser la logique de tri sur plusieurs endroits - auquel cas l'implémentation sort.Interface est logique.

Fondamentalement, c'est tout.

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!