Go slices.SortStableFunc 处理相等元素如何保持顺序

如果一批记录要先按分数排序，但分数相同的记录还要维持原来的到达顺序，应该使用 slices.SortStableFunc，并让比较器在主键相等时返回 0。它保证的是“比较器认为等价”的元素保持相对顺序，不是把所有字段都比较一遍。只要在相等分支里再比较 id，这组记录就不再是等价元素，稳定性也不会替你保留原顺序。

先分清“相等主键”和“完全相同记录”

SortStableFunc 接收一个切片和比较器。比较器对两个元素返回负数、零或正数，分别表示前者应排在后面、两者等价或前者应排在前面。稳定排序关心的是返回零的那一组：排序后它们的相对次序不变。

例如按 score 排名时，score 相同就应返回零，即使两条记录的 id、时间或来源不同。这里的“相等”是排序语义中的等价，不要求结构体每个字段都相同。

用一个不带次关键字的比较器保持原顺序

package main

import (
    "cmp"
    "fmt"
    "slices"
)

type Entry struct {
    ID    string
    Score int
}

func main() {
    entries := []Entry{
        {ID: "A", Score: 90},
        {ID: "B", Score: 80},
        {ID: "C", Score: 90},
        {ID: "D", Score: 80},
    }

    // 只按 Score 排序；同分时返回 0，交给稳定排序保留原顺序。
    slices.SortStableFunc(entries, func(a, b Entry) int {
        return cmp.Compare(b.Score, a.Score) // 分数高的排在前面。
    })

    // 输出顺序应为 A、C、B、D；同分记录仍按输入先后排列。
    fmt.Println(entries)
}

这个例子中，A 和 C 都是 90 分，输入里 A 先出现，所以排序后仍然是 A、C；80 分组同理保留 B、D。比较器使用 cmp.Compare(b.Score, a.Score) 是为了降序排列，交换两个参数即可改成升序。

用同组 id 序列验证稳定性

只看最终分数序列不够，因为普通排序也可能碰巧给出同样结果。更可靠的检查是记录每个等价组在排序前后的 id 顺序。下面的测试故意让 90 分和 80 分各出现两次，断言排序后的同分组序列。

package main

import (
    "cmp"
    "slices"
    "testing"
)

func TestStableScoreOrder(t *testing.T) {
    entries := []Entry{
        {ID: "A", Score: 90}, {ID: "B", Score: 80},
        {ID: "C", Score: 90}, {ID: "D", Score: 80},
    }

    // 只比较 Score，让相同分数构成稳定等价组。
    slices.SortStableFunc(entries, func(a, b Entry) int {
        return cmp.Compare(b.Score, a.Score)
    })

    want := []Entry{
        {ID: "A", Score: 90}, {ID: "C", Score: 90},
        {ID: "B", Score: 80}, {ID: "D", Score: 80},
    }
    // 用结构体切片比较期望结果，输入改变时测试会明确失败。
    if !slices.Equal(entries, want) {
        t.Fatalf("stable order = %#v, want %#v", entries, want)
    }
}

检查点有两个：先确认分数整体有序，再确认同分的 id 顺序仍与输入一致。若比较器改成“先按分数、再按 id”，测试结果会随 id 排序，这时它可能仍然有序，却已经不再验证稳定性。

不要用 tie-breaker 误解稳定排序

下面这种写法并不错误，但它表达的是另一种需求：分数相同还要按 ID 排序。因为比较器已经把同分记录区分开，SortStableFunc 没有理由继续保留它们的输入顺序。

// 需要确定的二级顺序时，明确写出 tie-breaker。
slices.SortStableFunc(entries, func(a, b Entry) int {
    if a.Score != b.Score {
        return cmp.Compare(b.Score, a.Score) // 先按分数降序。
    }
    return cmp.Compare(a.ID, b.ID) // 同分再按 ID，稳定等价组已被拆开。
})

另外，SortStableFunc 会直接修改传入的切片底层数组。如果调用方还需要原始到达顺序，可以先复制再排：

// 复制一份再排序，保留 entries 的原始顺序供日志或审计使用。
ordered := slices.Clone(entries)
slices.SortStableFunc(ordered, func(a, b Entry) int {
    return cmp.Compare(b.Score, a.Score) // 同分返回 0，保留 ordered 的输入顺序。
})

常见问题

比较器返回 0 时，两个元素必须完全相同吗？

不需要。返回 0 只表示在当前排序规则下等价；例如两条记录可以分数相同但 ID 不同。

SortStableFunc 会返回新的切片吗？

不会，它在原切片上排序。需要保留原顺序时先使用 slices.Clone。

为什么加入 ID 排序后看不到稳定性？

因为 ID 已经成为次关键字，同分元素不再返回 0。此时测试的目标是确定的二级排序，而不是保留输入顺序。