Go语言sort.Slice自定义排序的闭包写法与稳定性

Go 语言的 sort 包提供了非常便捷的切片排序功能。通过闭包，我们可以极简地实现各种自定义排序逻辑。然而，在使用 sort.Slice 时，必须注意其底层算法并非稳定排序，这在处理多字段排序或需要保留原始相对顺序的场景下至关重要。

以下步骤将指导你如何编写闭包排序，并解决稳定性问题。

1. 准备基础数据结构

首先，我们需要定义一个结构体切片，用于演示排序操作。

1. 定义 一个 Person 结构体，包含 Name（姓名）和 Age（年龄）字段。
2. 初始化 一个包含多个 Person 对象的切片，特意设置重复年龄的情况以测试稳定性。

package main

import (
    "fmt"
    "sort"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    // 初始化切片，注意有两个 Age 为 25 的人
    people := []Person{
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 25},
        {"David", 20},
    }

    // 后续代码将在此处添加
}

2. 使用 sort.Slice 实现基础排序

sort.Slice 函数要求传入一个切片和一个匿名函数（闭包）。该闭包定义了排序规则：返回 true 表示索引 i 的元素应该排在索引 j 的元素之前。

1. 调用 sort.Slice 函数，传入 people 切片。
2. 编写 闭包逻辑，使用 p[i].Age < p[j].Age 实现按年龄升序排列。

    // 基础排序：按年龄升序
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })

    fmt.Println("按年龄排序:", people)

执行结果：此时切片将按照 20, 25, 25, 30 的顺序排列。但是，请注意两个 25 岁的人（Alice 和 Charlie）的顺序。在某些 Go 版本或特定数据量下，由于底层使用的是快速排序，它们的相对顺序可能会发生变化，这就是“不稳定”的表现。

3. 实现多字段自定义排序

在实际业务中，我们经常需要先按一个字段排序，如果该字段相同，再按另一个字段排序。例如：先按年龄升序，年龄相同的按姓名降序。

1. 修改 闭包内部的逻辑。
2. 添加 判断条件：如果年龄不同，比较年龄；如果年龄相同，比较姓名。

    // 多字段排序：先按年龄升序，年龄相同则按姓名降序
    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 // 姓名降序
    })

    fmt.Println("多字段排序:", people)

执行逻辑：

• 比较 people[i] 和 people[j] 的 Age。
• 若不等，年龄小的排在前面。
• 若相等，利用字符串字典序，姓名大的（字典序靠后的）排在前面。

4. 理解并解决排序稳定性问题

sort.Slice 在 Go 语言底层实现中通常采用快速排序，这是一种不稳定的排序算法。这意味着当两个元素比较结果相等（如上述例子中年龄同为 25）时，它们在排序后的相对顺序是不确定的。

为了确保“相等元素的原始相对顺序保持不变”，必须使用 sort.SliceStable。

稳定性对比图解

下面的流程图展示了在不稳定排序与稳定排序中，对于相同键值元素的处理差异。

1. 替换 sort.Slice 为 sort.SliceStable。
2. 保持 闭包逻辑不变。

    // 稳定排序：确保相同年龄的人保持原始输入顺序（先Alice后Charlie）
    // 为了演示，我们先重置切片
    people = []Person{
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 25}, // Alice 在 Charlie 前面
        {"David", 20},
    }

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

    fmt.Println("稳定排序结果:", people)
    // 输出将严格保证 David(20), Alice(25), Charlie(25), Bob(30)
    // Alice 始终在 Charlie 前面

5. 闭包捕获变量的注意事项

在编写闭包时，虽然 sort.Slice 的参数列表里没有直接传入切片，但闭包通过捕获外部的 people 变量来访问数据。

1. 确保 闭包内部引用的变量（如 people）是已初始化的。
2. 避免 在闭包内部修改切片的长度（如 append），只应读取内容用于比较。排序过程仅涉及元素交换，不应改变切片大小。

    // 错误示范：不要在闭包里做除了比较以外的操作
    sort.Slice(people, func(i, j int) bool {
        // 不要在这里修改 people
        // people = append(people, Person{"New", 0}) 
        return people[i].Age < people[j].Age
    })

通过以上步骤，你已经掌握了 Go 语言中使用闭包进行 sort.Slice 自定义排序的核心写法，并理解了在需要保持原始顺序时如何选择 sort.SliceStable。