Go slices稳定去重并保留首次出现顺序的实现方法

Go 切片要做“稳定去重”，核心不是排序，而是按输入顺序遍历，并用一个 seen 集合记住已经出现过的值。第一次遇到某个值就追加到结果，后面再次遇到时跳过，因此既能去掉全局重复，也能保留首次出现顺序。官方 slices 文档中，slices.Compact 只合并连续相等元素，不能直接替代这种稳定去重方案。

官方地址：https://pkg.go.dev/slices

如果元素类型满足 comparable，优先使用“遍历切片 + map 判重 + 结果切片”的实现。它的平均时间复杂度是 O(n)，结果顺序稳定；只有当元素不能直接比较，或业务相等规则不是 Go 的 == 时，才换成键提取或自定义比较。

先分清全局去重和相邻去重

例如输入 ["go", "rust", "go", "java", "rust"]，目标结果是 ["go", "rust", "java"]。这里的重复项不一定相邻，所以只调用 slices.Compact 得不到目标结果；它适合的是 [1, 1, 2, 2, 3] 这类已经按相同值聚成连续区段的数据。

如果先排序再去重，虽然也能消除重复，但排序会改变调用方依赖的输入顺序。稳定去重的验收标准只有两个：每个值最多出现一次；每个值在结果中的位置由它第一次出现在输入中的位置决定。

用 seen map 保留第一次出现的值

实现时让 seen 只负责判断，让 result 负责保存顺序。不要遍历 map 生成结果，因为 map 的遍历顺序不应当承担业务顺序。

package main

import "fmt"

// StableUnique 保留每个元素第一次出现的顺序，并跳过后续重复值。
func StableUnique[T comparable](items []T) []T {
	seen := make(map[T]struct{}, len(items)) // 集合只做判重，不参与结果排序
	result := make([]T, 0, len(items))       // 预留容量，减少追加时的扩容
	for _, item := range items {
		if _, exists := seen[item]; exists {
			continue // 已出现过的值不再写入结果
		}
		seen[item] = struct{}{}
		result = append(result, item) // 只有首次出现的值进入结果
	}
	return result
}

func main() {
	input := []string{"go", "rust", "go", "java", "rust"}
	fmt.Println(StableUnique(input)) // [go rust java]
}

这里的泛型约束是 comparable，因为 map 的键必须支持相等比较。struct{}{} 不占用额外值字段，适合作为“只关心是否存在”的集合元素。结果切片按输入遍历顺序追加，所以稳定性来自循环本身，而不是 map。

把空输入、nil 和别名切片处理清楚

空切片不需要特殊分支也能正确返回空结果，但要先决定 API 是否需要保留 nil。上面的实现对 nil 输入返回一个非 nil 的空切片，因为它预分配了 make([]T, 0, 0)。如果调用方用 nil 表示“字段未提供”，可以显式保留这个语义：

func StableUniqueKeepNil[T comparable](items []T) []T {
	if items == nil {
		return nil // 保留调用方用 nil 表示缺省值的语义
	}
	seen := make(map[T]struct{}, len(items))
	result := make([]T, 0, len(items))
	for _, item := range items {
		if _, exists := seen[item]; exists {
			continue // 全局重复项只保留第一次
		}
		seen[item] = struct{}{}
		result = append(result, item)
	}
	return result
}

这个函数创建了新结果，不会覆盖原切片中的元素。若业务允许原地改写，可以把唯一值写回输入切片的前部再截短长度，但要明确调用方仍持有同一底层数组，避免产生共享数据的副作用。

按元素类型选择实现

字符串、整数、布尔值以及字段全部可比较的结构体，都可以直接使用泛型 map 方案。若元素包含切片、map 或函数字段，就不能把整个结构体作为 map key；这时通常提取一个稳定且可比较的业务键：

type User struct {
	ID   int
	Name string
}

func UniqueUsers(users []User) []User {
	seenID := make(map[int]struct{}, len(users)) // 以业务唯一键判重
	result := make([]User, 0, len(users))
	for _, user := range users {
		if _, exists := seenID[user.ID]; exists {
			continue // 同一 ID 保留最早出现的完整记录
		}
		seenID[user.ID] = struct{}{}
		result = append(result, user)
	}
	return result
}

如果“相等”是忽略大小写、忽略空格或按多个字段组合判断，就把规范化后的字符串或组合键放入 seen。只有当键无法可靠提取时，才使用结果切片上的线性比较；那种写法更通用，但最坏时间复杂度会退化到 O(n²)。

复杂度、边界与速查表

map 判重方案平均需要 O(n) 次查找，额外空间约为 O(k)，其中 k 是不同值的数量；结果切片还需要保存最多 n 个元素。输入很大时，提前用 len(items) 预留容量可以减少扩容，但并不改变渐进复杂度。

相关问题

稳定去重后还需要排序怎么办？

先明确是否还需要“首次出现顺序”。如果排序是最终展示要求，可以在稳定去重后单独排序；不要为了方便把排序提前，否则就无法再恢复首次出现顺序。

slices.Compact 会修改原切片吗？

会复用并修改传入切片的内容，再返回缩短后的切片。它适合清理连续重复段；需要全局稳定去重时，使用 seen 集合更直接。