Ordenación con el paquete sort

El paquete estándar sort ordena los sectores in situ. Para tipos básicos (int, float64, string) hay ayudantes directos; para cualquier otra rebanada usas sort.Slice con una función less(i, j int) bool que define la clasificación.

Ayudante para tipos básicos

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]

La clasificación es in situ: el segmento original está mutado.

sort.Slice: clasificación personalizada

Pasas el segmento y una función less que, dados dos índices i y j, devuelve true si el elemento i debe ir antes 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)

Para ordenar a la inversa, simplemente intercambie la comparación: return people[i].Age > people[j].Age.

Pedido estable

No se garantiza que sort.Slice sea estable (los mismos elementos pueden cambiar) orden relativo). Para una clasificación estable, utilice sort.SliceStable:

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

Ordenar por múltiples claves

Patrón común: ordenar por edad y con la misma edad por nombre:

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

Búsqueda binaria

sort.SearchInts / sort.Search funcionan en sectores ya ordenados:

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

Si el elemento no está allí, se devuelve el índice de inserción. Puedes encontrarlo en detalles cuando los necesite.

Genéricos (Go 1.21+): slices.Sort

Del paquete 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 más moderna y con seguridad de tipos. Compatible con sort.Slice pero más ergonómico.

Pruébalo tú mismo

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

Resumen

• sort.Ints / sort.Strings / sort.Float64s para tipos básicos in situ.
• sort.Slice(s, less) para cortes de cualquier tipo, con función less(i, j).
• sort.SliceStable para mantener el orden relativo con la misma clave.
• Clasificación por múltiples claves: cascada de if en less.
• Ir a 1.21+: paquete slices con API genérica (slices.Sort, slices.SortFunc).
• Para claves de mapa: extraer en porciones y ordenar.