Menyortir dengan paket sortir

Paket standar sort mengurutkan irisan di tempat. Untuk tipe dasar (int, float64, string) ada pembantu langsung; untuk irisan lainnya Anda gunakan sort.Slice dengan fungsi less(i, j int) bool yang mendefinisikan memesan.

Pembantu untuk tipe dasar

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]

Pengurutannya di tempat: potongan asli dimutasi.

sort.Slice: penyortiran khusus

Anda meneruskan irisan dan fungsi less yang diberi dua indeks i dan j, mengembalikan true jika elemen i harus berada sebelum 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)

Untuk mengurutkan secara terbalik, cukup balikkan perbandingannya: return people[i].Age > people[j].Age.

Jenis yang stabil

sort.Slice tidak dijamin stabil (elemen "sama" dapat berubah urutan relatif). Untuk pengurutan stabil, gunakan sort.SliceStable:

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

Menyortir berdasarkan beberapa tombol

Pola umum: urutkan berdasarkan usia, dan untuk usia yang sama berdasarkan nama:

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

Pencarian biner

sort.SearchInts / sort.Search mengerjakan irisan yang sudah diurutkan:

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

Jika elemen tidak ada, ia mengembalikan indeks penyisipan. Anda bisa menggali ke dalam rincian ketika Anda membutuhkannya.

Generik (Go 1.21+): slices.Sort

Dari paket slices di 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 yang lebih modern dan aman untuk tipe. Kompatibel dengan sort.Slice tetapi lebih dari itu ergonomis.

Cobalah

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

Rekap

• sort.Ints / sort.Strings / sort.Float64s untuk tipe dasar, di tempat.
• sort.Slice(s, less) untuk irisan jenis apa pun, dengan fungsi less(i, j).
• sort.SliceStable untuk menjaga urutan relatif untuk kunci yang sama.
• Mengurutkan berdasarkan beberapa kunci: rangkaian if di dalam less.
• Go 1.21+: paket slices dengan API generik (slices.Sort, slices.SortFunc).
• Untuk kunci peta: ekstrak menjadi beberapa bagian dan urutkan.