Go语言中结构体切片的多维度排序技巧

package main

import (
    "fmt"
    "sort"
)

// Point 结构体表示一个多维点
type Point struct {
    x          int
    y          int
    country_id int
}

// String 方法用于方便打印 Point
func (p *Point) String() string {
    return fmt.Sprintf("{x:%d, y:%d, country_id:%d}", p.x, p.y, p.country_id)
}

// Points 类型是 Point 指针切片的别名
type Points []*Point

// Print 方法用于打印 Points 切片
func (p Points) Print(label string) {
    fmt.Printf("%s: %v\n", label, p)
}

// SortByX 类型用于按 Point 的 x 值排序
type SortByX Points

func (s SortByX) Len() int           { return len(s) }
func (s SortByX) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
func (s SortByX) Less(i, j int) bool { return s[i].x < s[j].x } // 核心：按 x 排序

// SortByY 类型用于按 Point 的 y 值排序
type SortByY Points

func (s SortByY) Len() int           { return len(s) }
func (s SortByY) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
func (s SortByY) Less(i, j int) bool { return s[i].y < s[j].y } // 核心：按 y 排序

func main() {
    myPoints := Points{
        &Point{x: 3, y: 10, country_id: 1},
        &Point{x: 1, y: 20, country_id: 2},
        &Point{x: 2, y: 5, country_id: 1},
    }

    fmt.Println("--- 方法一：独立定义排序类型 ---")
    myPoints.Print("原始数据")

    // 按 y 值排序
    sort.Sort(SortByY(myPoints))
    myPoints.Print("按 y 排序后")

    // 按 x 值排序
    sort.Sort(SortByX(myPoints))
    myPoints.Print("按 x 排序后")
}

// SortablePoints 是一个基础类型，包含 Len() 和 Swap() 方法
type SortablePoints Points

func (s SortablePoints) Len() int      { return len(s) }
func (s SortablePoints) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

// SortPointsByX 嵌入 SortablePoints，并实现自己的 Less() 方法
type SortPointsByX struct {
    SortablePoints
}
func (s SortPointsByX) Less(i, j int) bool {
    return s.SortablePoints[i].x < s.SortablePoints[j].x
}

// SortPointsByY 嵌入 SortablePoints，并实现自己的 Less() 方法
type SortPointsByY struct {
    SortablePoints
}
func (s SortPointsByY) Less(i, j int) bool {
    return s.SortablePoints[i].y < s.SortablePoints[j].y
}

func main() {
    myPoints := Points{
        &Point{x: 3, y: 10, country_id: 1},
        &Point{x: 1, y: 20, country_id: 2},
        &Point{x: 2, y: 5, country_id: 1},
    }

    fmt.Println("\n--- 方法二：利用类型嵌入共享通用操作 ---")
    myPoints.Print("原始数据")

    // 按 y 值排序
    sort.Sort(SortPointsByY{SortablePoints: SortablePoints(myPoints)})
    myPoints.Print("按 y 排序后")

    // 按 x 值排序
    sort.Sort(SortPointsByX{SortablePoints: SortablePoints(myPoints)})
    myPoints.Print("按 x 排序后")
}

// Points 类型实现 Len() 和 Swap() 方法
// 注意：为了与方法一和方法二区分，这里我们假设 Points 类型自身不实现 Less()，
// 而是通过一个辅助结构体来完成。
type PointsWithCustomSort []*Point

func (p PointsWithCustomSort) Len() int      { return len(p) }
func (p PointsWithCustomSort) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

// pointsSorter 是一个辅助结构体，用于将自定义比较函数传递给 sort.Sort
type pointsSorter struct {
    PointsWithCustomSort
    less func(i, j int) bool
}

// Less 方法调用传入的自定义比较函数
func (s pointsSorter) Less(i, j int) bool {
    return s.less(i, j)
}

// Sort 方法接受一个自定义比较函数，实现多维度排序
func (p PointsWithCustomSort) Sort(less func(i, j int) bool) {
    sort.Sort(pointsSorter{PointsWithCustomSort: p, less: less})
}

func main() {
    myPoints := PointsWithCustomSort{
        &Point{x: 3, y: 10, country_id: 1},
        &Point{x: 1, y: 20, country_id: 2},
        &Point{x: 2, y: 5, country_id: 1},
    }

    fmt.Println("\n--- 方法三：使用自定义比较函数 ---")
    myPoints.Print("原始数据")

    // 按 y 值排序
    myPoints.Sort(func(i, j int) bool {
        return myPoints[i].y < myPoints[j].y
    })
    myPoints.Print("按 y 排序后")

    // 按 x 值排序
    myPoints.Sort(func(i, j int) bool {
        return myPoints[i].x < myPoints[j].x
    })
    myPoints.Print("按 x 排序后")

    // 示例：按 country_id 排序
    myPoints.Sort(func(i, j int) bool {
        return myPoints[i].country_id < myPoints[j].country_id
    })
    myPoints.Print("按 country_id 排序后")
}