Tri avec le package sort

Le package standard sort trie les tranches sur place. Pour les types de base (int, float64, string) il existe des aides directes ; pour toute autre tranche vous utilisez sort.Slice avec une fonction less(i, j int) bool qui définit le tri.

Helper pour les types de base

import "sort"

nums := []int{5, 2, 8, 1}
sort.Ints(nums)        // [1 2 5 8]

words := []string{"c", "a", "b"}
sort.Strings(words)    // [a b c]

fs := []float64{1.5, 0.5, 2.5}
sort.Float64s(fs)      // [0.5 1.5 2.5]

Le tri est sur place : la tranche d'origine est mutée.

sort.Slice : tri personnalisé

Vous passez la tranche et une fonction less qui, étant donné deux indices i et j, renvoie true si l'élément i doit précéder j :

type Person struct {
    Name string
    Age  int
}

people := []Person{
    {"Bruno", 30},
    {"Anna", 25},
    {"Carla", 28},
}

sort.Slice(people, func(i, j int) bool {
    return people[i].Age < people[j].Age
})
// Anna(25), Carla(28), Bruno(30)

Pour trier à l'envers, échangez simplement la comparaison : return people[i].Age > people[j].Age.

Ordre stable

sort.Slice n'est pas garanti stable (les "mêmes" éléments peuvent changer ordre relatif). Pour un tri stable, utilisez sort.SliceStable :

sort.SliceStable(people, func(i, j int) bool {
    return people[i].Age < people[j].Age
})

Tri par plusieurs clés

Modèle commun : trier par âge, et avec le même âge par nom :

sort.Slice(people, func(i, j int) bool {
    if people[i].Age != people[j].Age {
        return people[i].Age < people[j].Age
    }
    return people[i].Name < people[j].Name
})

Recherche binaire

sort.SearchInts / sort.Search travaille sur des tranches déjà triées :

nums := []int{1, 3, 5, 7, 9}
i := sort.SearchInts(nums, 5)   // 2

Si l'élément n'est pas là, l'index d'insertion est renvoyé. Vous pouvez le trouver dans détails lorsque vous en avez besoin.

Génériques (Go 1.21+) : slices.Sort

Depuis le package slices de stdlib (Go 1.21) :

import "slices"

nums := []int{3, 1, 2}
slices.Sort(nums)               // [1 2 3]
slices.SortFunc(people, func(a, b Person) int {
    return a.Age - b.Age        // -1/0/1
})

API plus moderne et sécurisée. Compatible avec sort.Slice mais plus ergonomique.

Essayez-le vous-même

sort.Slice(s, func(i, j int) bool { return ??? })

Récapitulatif

• sort.Ints / sort.Strings / sort.Float64s pour les types de base sur place.
• sort.Slice(s, less) pour les tranches de tout type, avec fonction less(i, j).
• sort.SliceStable pour maintenir l'ordre relatif avec la même clé.
• Tri par plusieurs clés : cascade de if dans less.
• Go 1.21+ : package slices avec API générique (slices.Sort, slices.SortFunc).
• Pour les clés de carte : extraire en tranches et trier.