sort

TIP

Si vous êtes un développeur utilisant la version 1.21 ou supérieure, je vous recommande d'utiliser la bibliothèque standard slices pour le tri. Elle supporte les génériques et son API est mieux conçue.

En Go, le package sort fournit les méthodes de tri officiellement implémentées. La plupart peuvent être utilisées directement. Si vous souhaitez trier des structures, vous devez implémenter les trois méthodes de l'interface sort.Interface : Len(), Swap(), Less(). Comme Go a déjà implémenté les types Float64Slice, StringSlice, IntSlice, vous pouvez utiliser ces trois types directement sans les implémenter vous-même.

type Interface interface {
   // Méthode de longueur
   Len() int

   // Méthode de comparaison
   Less(i, j int) bool

   // Méthode d'échange
   Swap(i, j int)
}

Tri d'entiers

func main() {
   ints := []int{1, 2, 3, 111, 5, 99, 23, 5, 66}
   sort.Ints(ints)
}

Tri de nombres à virgule flottante

func main() {
   floats := []float64{1.0, 2.5, 3.8, 1.11, 5.5, 99.99999, 23.9999, 5.66, 66}
   sort.Float64s(floats)
   fmt.Println(floats)
}

Tri de chaînes

func main() {
   strings := []string{"helloworld", "aaa", "bbb", "ccc"}
   sort.Strings(strings)
}

Tri inversé

Il faut d'abord envelopper avec sort.Reverse puis trier

func main() {
  floats := []float64{1.0, 2.5, 3.8, 1.11, 5.5, 99.99999, 23.9999, 5.66, 66}
  sort.Sort(sort.Reverse(sort.Float64Slice(floats)))
  fmt.Println(floats)
}

Tri personnalisé

Si vous souhaitez trier une structure personnalisée, vous devez implémenter les trois méthodes.

type Person struct {
  UserId   string
  Username string
  Age      int
  Address  string
}

type PersonSlice []Person

//Retourne la longueur de la tranche
func (p PersonSlice) Len() int {
  return len(p)
}

//Méthode de comparaison
func (p PersonSlice) Less(i, j int) bool {
  return p[i].Age < p[j].Age
}

//Méthode d'échange
func (p PersonSlice) Swap(i, j int) {
  p[i], p[j] = p[j], p[i]
}

Comme la comparaison est basée sur l'âge, le résultat sera trié selon l'âge.

func main() {
   persons := []Person{{
      UserId:   "1",
      Username: "wyh",
      Age:      18,
      Address:  "us",
   }, {
      UserId:   "2",
      Username: "jack",
      Age:      17,
      Address:  "ch",
   }, {
      UserId:   "3",
      Username: "mike",
      Age:      15,
      Address:  "india",
   }}

   sort.Sort(PersonSlice(persons))

   fmt.Println(persons)
}

Vérifier si trié

Vérifie si une tranche est triée. En interne, elle n'effectue pas de tri mais détermine le résultat en appelant Less() en boucle

func main() {
   persons := []Person{{
      UserId:   "1",
      Username: "wyh",
      Age:      18,
      Address:  "us",
   }, {
      UserId:   "2",
      Username: "jack",
      Age:      17,
      Address:  "ch",
   }, {
      UserId:   "3",
      Username: "mike",
      Age:      15,
      Address:  "india",
   }}

   sort.Sort(PersonSlice(persons))

   println(sort.IsSorted(PersonSlice(persons)))
}