सॉर्ट पैकेज के साथ सॉर्टिंग

मानक sort पैकेज स्थान में स्लाइस को क्रमबद्ध करता है। आधार प्रकार के लिए (int, फ्लोट64, स्ट्रिंग) प्रत्यक्ष सहायक हैं; किसी अन्य टुकड़े के लिए आप less(i, j int) bool फ़ंक्शन के साथ sort.Slice का उपयोग करें जो परिभाषित करता है आदेश देना

आधार प्रकारों के लिए सहायक

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 j से पहले आना चाहिए, तो 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
})

अधिक आधुनिक, प्रकार-सुरक्षित एपीआई। sort.Slice लेकिन अधिक के साथ संगत एर्गोनॉमिक.

इसे अजमाएं

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

संक्षिप्त

• sort.Ints / sort.Strings / sort.Float64s आधार प्रकारों के लिए, यथास्थान।
• less(i, j) फ़ंक्शन के साथ, किसी भी प्रकार के स्लाइस के लिए sort.Slice(s, less)।
• sort.SliceStable समान कुंजियों के सापेक्ष क्रम को संरक्षित करने के लिए।
• एकाधिक कुंजियों के आधार पर क्रमबद्ध करना: less के अंदर ifs का एक झरना।
• 1.21+ पर जाएं: slices पैकेज एक सामान्य एपीआई के साथ (slices.Sort, slices.SortFunc)।
• मानचित्र कुंजियों के लिए: एक स्लाइस में निकालें और क्रमबद्ध करें।