வரிசையாக்க தொகுப்புடன் வரிசைப்படுத்துதல்

நிலையான sort தொகுப்பு துண்டுகளை இடத்தில் வரிசைப்படுத்துகிறது. அடிப்படை வகைகளுக்கு (int, float64, string) நேரடி உதவியாளர்கள் உள்ளனர்; வேறு எந்த துண்டுக்கும் நீங்கள் sort.Sliceஐ less(i, j int) bool செயல்பாட்டுடன் பயன்படுத்தவும் ஆர்டர்.

அடிப்படை வகைகளுக்கான உதவியாளர்கள்

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]

வரிசையானது இடத்தில்: அசல் ஸ்லைஸ் மாற்றப்பட்டது.

sort.Slice: தனிப்பயன் வரிசையாக்கம்

இரண்டு குறியீடுகள் i மற்றும் கொடுக்கப்பட்ட ஸ்லைஸ் மற்றும் less செயல்பாட்டைக் கடந்துவிட்டீர்கள் j, jக்கு முன் உறுப்பு i வர வேண்டும் என்றால் true ஐ வழங்குகிறது:

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)

தலைகீழாக வரிசைப்படுத்த, ஒப்பீட்டைப் புரட்டவும்: return people[i].Age > people[j].Age.

நிலையான வரிசை

sort.Slice நிலையானது என்பதற்கு உத்தரவாதம் இல்லை ("சமமான" கூறுகள் மாறலாம் உறவினர் ஒழுங்கு). நிலையான வரிசைக்கு sort.SliceStable:

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

பல விசைகள் மூலம் வரிசைப்படுத்துதல்

பொதுவான முறை: வயதின்படி வரிசைப்படுத்தவும், பெயரின்படி சம வயதுக்கு:

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

பைனரி தேடல்

sort.SearchInts / sort.Search ஏற்கனவே வரிசைப்படுத்தப்பட்ட துண்டுகளில் வேலை:

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

உறுப்பு இல்லை என்றால், அது செருகும் குறியீட்டை வழங்கும். நீங்கள் தோண்டலாம் உங்களுக்கு அவை தேவைப்படும் போது விவரங்கள்.

ஜெனரிக்ஸ் (Go 1.21+): slices.Sort

slices தொகுப்பிலிருந்து stdlib இல் (செல் 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. sort.Slice உடன் இணக்கமானது ஆனால் பல பணிச்சூழலியல்.

முயற்சி செய்து பாருங்கள்

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

மறுபரிசீலனை

• sort.Ints / sort.Strings / sort.Float64s அடிப்படை வகைகளுக்கு, இடத்தில்.
• sort.Slice(s, less) எந்த வகை துண்டுகளுக்கும், less(i, j) செயல்பாட்டுடன்.
• sort.SliceStable சம விசைகளுக்கான தொடர்புடைய வரிசையைப் பாதுகாக்க.
• பல விசைகள் மூலம் வரிசைப்படுத்துதல்: less உள்ளே ifவி.
• செல் 1.21+: slices தொகுப்பு பொது API (slices.Sort, slices.SortFunc).
• வரைபட விசைகளுக்கு: ஒரு துண்டுகளாக பிரித்தெடுத்து வரிசைப்படுத்தவும்.