Sortare cu pachetul de sortare

Pachetul standard sort sortează feliile la loc. Pentru tipurile de bază (int, float64, string) există ajutoare direcți; pentru orice altă felie tu utilizați sort.Slice cu o funcție less(i, j int) bool care definește ordonând.

Ajutoare pentru tipuri de baze

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]

Sortarea este la loc: felia originală este mutată.

sort.Slice: sortare personalizată

Treci felia și o funcție less care, având în vedere doi indici i și j, returnează true dacă elementul i ar trebui să apară înainte de 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)

Pentru a sorta invers, doar întoarceți comparația: return people[i].Age > people[j].Age.

Sortare stabilă

sort.Slice nu este garantat a fi stabil (elementele „egale” se pot schimba ordine relativă). Pentru o sortare stabilă, utilizați sort.SliceStable:

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

Sortare după mai multe taste

Model comun: sortați după vârstă și pentru vârste egale după nume:

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

Căutare binară

sort.SearchInts / sort.Search lucrează pe felii deja sortate:

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

Dacă elementul nu este acolo, returnează indexul de inserare. Poți să sapi în detalii când aveți nevoie de ele.

Generic (Go 1.21+): slices.Sort

Din pachetul slices din 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 mai modern, sigur de tip. Compatibil cu sort.Slice dar mai mult ergonomic.

Încearcă

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

Recapitulare

• sort.Ints / sort.Strings / sort.Float64s pentru tipurile de bază, pe loc.
• sort.Slice(s, less) pentru felii de orice tip, cu o funcție less(i, j).
• sort.SliceStable pentru a păstra ordinea relativă pentru cheile egale.
• Sortare după mai multe chei: o cascadă de if-uri în interiorul less.
• Treceți la 1.21+: pachet slices cu un API generic (slices.Sort, slices.SortFunc).
• Pentru cheile de hartă: extrageți într-o felie și sortați.