Go sort Package

nums := []int{5, 2, 8, 1, 9, 3}
sort.Slice(nums, func(i, j int) bool {
    return nums[i] < nums[j]   // ascending
})
// [1 2 3 5 8 9]

// Descending — flip the comparison
sort.Slice(nums, func(i, j int) bool {
    return nums[i] > nums[j]
})
// [9 8 5 3 2 1]

words := []string{"banana", "apple", "cherry"}
sort.Slice(words, func(i, j int) bool {
    return words[i] < words[j]
})
// [apple banana cherry]

type Person struct {
    Name string
    Age  int
}

people := []Person{
    {"Alice", 30},
    {"Bob", 25},
    {"Charlie", 35},
    {"Diana", 25},
}

// Sort by Age ascending
sort.Slice(people, func(i, j int) bool {
    return people[i].Age < people[j].Age
})
// [{Bob 25} {Diana 25} {Alice 30} {Charlie 35}]
// (Bob and Diana order is not guaranteed — use SliceStable for that)

// Sort by Name alphabetically
sort.Slice(people, func(i, j int) bool {
    return people[i].Name < people[j].Name
})
// [{Alice 30} {Bob 25} {Charlie 35} {Diana 25}]

// SliceStable guarantees that equal elements keep their original relative order
// Useful when sorting by one field but preserving a prior sort on another

// Step 1: sort by Name
sort.SliceStable(people, func(i, j int) bool {
    return people[i].Name < people[j].Name
})

// Step 2: sort by Age — Name order is preserved within equal ages
sort.SliceStable(people, func(i, j int) bool {
    return people[i].Age < people[j].Age
})
// [{Bob 25} {Diana 25} {Alice 30} {Charlie 35}]
// Bob comes before Diana (alphabetical) because SliceStable preserved it

type Employee struct {
    Dept   string
    Name   string
    Salary int
}

employees := []Employee{
    {"Eng", "Zara", 90000},
    {"Eng", "Alice", 95000},
    {"HR", "Bob", 70000},
    {"Eng", "Alice", 88000},
}

// Primary: Dept asc  Secondary: Name asc  Tertiary: Salary desc
sort.Slice(employees, func(i, j int) bool {
    a, b := employees[i], employees[j]
    if a.Dept != b.Dept {
        return a.Dept < b.Dept
    }
    if a.Name != b.Name {
        return a.Name < b.Name
    }
    return a.Salary > b.Salary  // highest salary first within same name
})
// [{Eng Alice 95000} {Eng Alice 88000} {Eng Zara 90000} {HR Bob 70000}]

type ByLength []string

func (b ByLength) Len() int           { return len(b) }
func (b ByLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
func (b ByLength) Less(i, j int) bool { return len(b[i]) < len(b[j]) }

words := ByLength{"peach", "kiwi", "pineapple", "fig"}
sort.Sort(words)
// [fig kiwi peach pineapple]

// Stable version — preserves original order for equal lengths
sort.Stable(words)

// sort.Reverse wraps any sort.Interface to sort in reverse
words := ByLength{"peach", "kiwi", "pineapple", "fig"}
sort.Sort(sort.Reverse(words))
// [pineapple peach kiwi fig]

// Also works with the convenience types
nums := sort.IntSlice{3, 1, 4, 1, 5}
sort.Sort(sort.Reverse(nums))
// [5 4 3 1 1]

// For sort.Slice, just flip the less function instead
sort.Slice(nums, func(i, j int) bool { return nums[i] > nums[j] })

// sort.IntSlice, sort.StringSlice, sort.Float64Slice
// implement sort.Interface so you can use sort.Search on them

nums := sort.IntSlice{1, 3, 5, 7, 9}

// Search within a sorted IntSlice
i := nums.Search(5)   // 2 — index of 5
i  = nums.Search(4)   // 2 — insertion point for 4

// You can call Sort directly on the value
s := sort.StringSlice{"banana", "apple", "cherry"}
s.Sort()
// [apple banana cherry]

nums := []int{1, 3, 5, 7, 9, 11}
target := 7

// Find index of target in a sorted ascending slice
i := sort.Search(len(nums), func(i int) bool {
    return nums[i] >= target
})

if i < len(nums) && nums[i] == target {
    fmt.Printf("found %d at index %d\n", target, i) // found 7 at index 3
} else {
    fmt.Println("not found")
}

// Find the insertion point for a new value
insert := sort.Search(len(nums), func(i int) bool {
    return nums[i] >= 6
})
// insert = 3  (6 would go between 5 and 7)

import (
    "cmp"
    "slices"
)

type Person struct{ Name string; Age int }

people := []Person{{"Alice", 30}, {"Bob", 25}, {"Carol", 30}}

// slices.SortFunc takes a cmp function (returns int) not a less function (returns bool)
// Use cmp.Compare for ordered types; chain with || 0 for multi-key
slices.SortFunc(people, func(a, b Person) int {
    if n := cmp.Compare(a.Age, b.Age); n != 0 {
        return n
    }
    return cmp.Compare(a.Name, b.Name)
})
// [{Bob 25} {Alice 30} {Carol 30}]