క్రమబద్ధీకరణ ప్యాకేజీతో క్రమబద్ధీకరించడం

ప్రామాణిక 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: అనుకూల క్రమబద్ధీకరణ

మీరు స్లైస్ మరియు less ఫంక్షన్‌లో ఉత్తీర్ణులయ్యారు, రెండు సూచికలు i మరియు 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

మూలకం లేకపోతే, అది చొప్పించే సూచికను అందిస్తుంది. మీరు తవ్వవచ్చు మీకు అవసరమైనప్పుడు వివరాలలోకి.

జెనరిక్స్ (గో 1.21+): slices.Sort

stdlibలో slices ప్యాకేజీ నుండి (వెళ్లండి 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 లోపల ifs క్యాస్కేడ్.
• 1.21+కి వెళ్లండి: slices సాధారణ APIతో ప్యాకేజీ (slices.Sort, slices.SortFunc).
• మ్యాప్ కీల కోసం: స్లైస్‌గా ఎక్స్‌ట్రాక్ట్ చేసి క్రమబద్ధీకరించండి.