sort

sort — sonlar, satrlar yoki o'zimiz yaratgan turlardan (struct) iborat slayslarni saralash (tartiblash) uchun mo'ljallangan standart paket.

import "sort"

1. Tayyor turlar uchun saralash: Ints(), Strings(), Float64s()

Eng oddiy sonlar, satrlar yoki kasr sonlar slaysini saralash uchun tayyor funksiyalar mavjud:

package main

import (
    "fmt"
    "sort"
)

func main() {
    nums := []int{5, 2, 8, 1, 9}
    sort.Ints(nums) // o'sish tartibida saralaydi
    fmt.Println(nums)

    strs := []string{"banan", "olma", "anor"}
    sort.Strings(strs) // alifbo tartibida saralaydi
    fmt.Println(strs)

    floats := []float64{3.2, 1.1, 2.5}
    sort.Float64s(floats)
    fmt.Println(floats)
}

Natija:

[1 2 5 8 9]
[anor banan olma]
[1.1 2.5 3.2]

[!IMPORTANT] sort.Ints(), Strings() va Float64s() slaysni o'z joyida (in-place) o'zgartiradi — ya'ni yangi slays qaytarmaydi, balki bergan slaysingizning ichidagi tartibni bevosita almashtiradi.

2. Kamayish tartibida saralash: sort.Reverse()

Yuqoridagi funksiyalar faqat o'sish tartibida saralaydi. Kamayish tartibida saralash uchun sort.Reverse() bilan birga ishlatiladi:

package main

import (
    "fmt"
    "sort"
)

func main() {
    nums := []int{5, 2, 8, 1, 9}

    // IntSlice — []int ni sort.Interface'ga aylantiradi, Reverse esa tartibni teskarilaydi
    sort.Sort(sort.Reverse(sort.IntSlice(nums)))

    fmt.Println(nums)
}

Natija:

[9 8 5 2 1]

3. O'zingiz yaratgan turlarni saralash: sort.Slice()

Agar structlardan iborat slaysni ma'lum bir maydon bo'yicha saralash kerak bo'lsa (masalan, odamlarni yoshi bo'yicha), sort.Slice() eng qulay usul hisoblanadi. Unga saralash "qoidasi"ni bildiruvchi funksiya (less — kim kimdan oldin kelishi kerak) beriladi:

package main

import "fmt"
import "sort"

type Person struct {
    Name string
    Age  int
}

func main() {
    people := []Person{
        {"Ali", 30},
        {"Vali", 25},
        {"Gani", 35},
    }

    // yoshi bo'yicha o'sish tartibida saralaymiz
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })

    fmt.Println(people)
}

Natija:

[{Vali 25} {Ali 30} {Gani 35}]

func(i, j int) bool funksiyasi — agar i-elementi j-elementidan oldin kelishi kerak bo'lsa true qaytaradi. Kamayish tartibida saralash uchun shunchaki < belgisini > ga almashtirish kifoya.

4. Saralangan slaysdan tezkor qidirish: sort.SearchInts()

Agar slays allaqachon saralangan bo'lsa, unda elementni oddiy sikl bilan emas, ikkilik qidiruv (binary search) orqali ancha tezroq topish mumkin:

package main

import (
    "fmt"
    "sort"
)

func main() {
    nums := []int{1, 3, 5, 7, 9} // saralangan bo'lishi SHART

    index := sort.SearchInts(nums, 5)

    fmt.Println(index)
}

Natija:

2

[!WARNING] sort.SearchInts() (va umuman sort.Search* oilasi) faqat allaqachon saralangan slays uchun to'g'ri ishlaydi. Agar slays saralanmagan bo'lsa, natija noto'g'ri bo'lishi mumkin — funksiya buni o'zi tekshirib bermaydi.

5. Saralanganligini tekshirish: sort.IntsAreSorted()

package main

import (
    "fmt"
    "sort"
)

func main() {
    isSorted := sort.IntsAreSorted([]int{1, 2, 3})

    fmt.Println(isSorted)
}

Natija:

true

Xulosa: qachon qaysi funksiya kerak?

[!NOTE] Go 1.21 dan boshlab, ko'p hollarda sort o'rniga generic (umumlashtirilgan) slices paketidagi slices.Sort() funksiyasini ishlatish tavsiya etiladi — u ham tezroq, ham qisqaroq yoziladi. Bu haqda keyingi darsda batafsil to'xtalamiz.