如何使用Golang sort排序切片_Golang sort排序方法示例

sort.Slice 是 Go 1.8 引入的灵活切片排序方式，支持任意类型切片按自定义逻辑排序，无需实现 sort.Interface；使用时需注意索引顺序、指针解引用及 Less 函数中避免耗时操作。

sort.Slice 是最常用也最灵活的切片排序方式

Go 1.8 引入的 sort.Slice 允许你对任意切片按自定义逻辑排序，无需实现 sort.Interface。它直接接收切片和一个比较函数（闭包），语义清晰、写法简洁。

常见错误是误传指针或搞错索引顺序，比如把 i > j 写成 i 导致逆序结果被当成正序。

• 比较函数必须返回 bool：当 i 应排在 j 前面时返回 true
• 切片必须是地址可寻址的（不能是字面量直接传参，如 sort.Slice([]int{1,2}, ...) 会报错）
• 原地排序，不创建新切片

ages := []int{32, 18, 45, 23}
sort.Slice(ages, func(i, j int) bool {
    return ages[i] < ages[j] // 升序
})
// ages == []int{18, 23, 32, 45}

sort.Strings / sort.Ints 等内置函数只适用于基础类型切片

当你处理的是 []string、[]int、[]float64 这类标准类型切片时，直接用对应函数最快，它们底层做了优化，比 sort.Slice 略快且更安全（不会因闭包捕获错误变量引发隐患）。

注意：这些函数**不支持自定义规则**。比如想按字符串长度排序 []string，就不能用 sort.Strings，必须退回 sort.Slice。

• sort.Strings 按字典序升序；sort.Ints 按数值升序
• 没有 sort.Floats 的逆序版本，要降序需配合 sort.Reverse
• 对 []*string 或含空值的切片，这些函数会 panic，得自己判空

names := []string{"zoe", "amy", "bob"}
sort.Strings(names) // ["amy", "bob", "zoe"]

sort.SliceStable 保留相等元素的原始相对位置

当排序依据不唯一（比如按结构体的某个字段排序，多个元素该字段值相同），而你又需要保持它们原来的先后顺序时，必须用 sort.SliceStable。普通 sort.Slice 不保证稳定性。

典型场景：先按分数降序，分数相同时按提交时间升序——第二级排序依赖原始顺序，否则时间信息会被打乱。

• 性能略低于 sort.Slice（稳定排序算法开销稍大）
• 比较函数写法和 sort.Slice 完全一致
• Go 标准库中只有 sort.SliceStable 和 sort.Stable 提供稳定性保障

type Student struct {
    Name  string
    Score int
}
students := []Student{{"a", 85}, {"b", 92}, {"c", 85}}
sort.SliceStable(students, func(i, j int) bool {
    return students[i].Score > students[j].Score // 高分在前
})
// "a" 和 "c" 分数相同，"a" 仍排在 "c" 前面

自定义结构体排序必须用 sort.Slice 或实现 Interface

对结构体切片排序，没有像 Python 的 key= 那样一键指定字段的方式。最直接的是用 sort.Slice + 闭包；如果同一结构体在多处按同一规则排序，可考虑实现 sort.Interface 接口，复用性更高。

容易忽略的点是：闭包里访问结构体字段时，若切片元素是指针（[]*T），记得解引用；若忘了加 *，可能静默排序失败（比如比较的是地址而非值）。

• 实现 Len()、Less(i,j)、Swap(i,j) 三个方法即可
• 方法接收者建议用指针（*[]T），避免复制大切片
• 不要在 Less 中做耗时操作（如网络请求、文件读取），它会被频繁调用

fruits := []struct{ Name string; Price float64 }{
    {"apple", 2.5}, {"banana", 1.8}, {"cherry", 3.2},
}
sort.Slice(fruits, func(i, j int) bool {
    return fruits[i].Price < fruits[j].Price
})

Go 的排序设计偏向显式与可控，没有“魔法”式的默认行为。真正复杂的地方往往不在怎么写，而在于：是否意识到相等元素的顺序会影响业务逻辑，以及是否在比较函数里无意引入了副作用或越界访问。