Sorteren met het sorteerpakket

Het standaardpakket sort sorteert segmenten in-place. Voor basistypen (int, float64, string) er zijn directe helpers; voor elk ander stukje jij gebruik sort.Slice met een less(i, j int) bool functie die de bestellen.

Helpers voor basistypen

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]

De sortering is in-place: het oorspronkelijke segment is gemuteerd.

sort.Slice: aangepaste sortering

Je geeft het segment en een less functie door die, gegeven twee indices i en j, retourneert true als element i vóór j moet komen:

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)

Om omgekeerd te sorteren, draait u gewoon de vergelijking om: BESCHERMD_INLINE_14.

Stabiele soort

Het is niet gegarandeerd dat sort.Slice stabiel is ("gelijke" elementen kunnen veranderen relatieve volgorde). Gebruik sort.SliceStable voor een stabiele sortering:

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

Sorteren op meerdere sleutels

Algemeen patroon: sorteer op leeftijd en voor gelijke leeftijden op naam:

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
})

Binaire zoekopdracht

sort.SearchInts / sort.Search werken aan reeds gesorteerde segmenten:

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

Als het element er niet is, retourneert het de invoegindex. Je kunt graven tot in de details wanneer u ze nodig heeft.

Generieke versies (Go 1.21+): slices.Sort

Van het slices pakket in 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
})

Modernere, typeveilige API. Compatibel met sort.Slice maar meer ergonomisch.

Probeer het

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

Samenvatten

• sort.Ints / sort.Strings / sort.Float64s voor basistypen, ter plaatse.
• sort.Slice(s, less) voor segmenten van elk type, met een less(i, j) functie.
• sort.SliceStable om de relatieve volgorde voor gelijke sleutels te behouden.
• Sorteren op meerdere sleutels: een cascade van ifs binnen less.
• Ga naar 1.21+: slices pakket met een generieke API (slices.Sort, slices.SortFunc).
• Voor kaartsleutels: uitpakken in een segment en sorteren.