在Go语言中对结构体切片进行多维度排序的策略与实践

package main

import (
    "fmt"
    "sort"
)

// Point 结构体定义了一个二维点以及一个国家ID
type Point struct {
    x          int
    y          int
    country_id int
}

// Points 是 Point 结构体切片的别名
type Points []*Point

// 实现 sort.Interface 的 Len 方法
func (points Points) Len() int {
    return len(points)
}

// 实现 sort.Interface 的 Swap 方法
func (points Points) Swap(i, j int) {
    points[i], points[j] = points[j], points[i]
}

// 初始实现：按 y 轴值进行排序
func (points Points) Less(i, j int) bool {
    return points[i].y < points[j].y
}

func main() {
    data := Points{
        {x: 1, y: 5, country_id: 101},
        {x: 3, y: 2, country_id: 102},
        {x: 2, y: 8, country_id: 101},
        {x: 4, y: 1, country_id: 103},
    }

    fmt.Println("原始数据:", data)

    // 按 y 轴排序
    sort.Sort(data)
    fmt.Println("按 y 轴排序后:", data)
}

// 不推荐的 Less 方法实现示例
var SORT_BY_X bool // 全局标志

func (points Points) Less(i, j int) bool {
    if SORT_BY_X {
        return points[i].x < points[j].x
    }
    return points[i].y < points[j].y
}

// XSortablePoints 用于按 x 轴排序
type XSortablePoints struct {
    Points // 嵌入 Points 类型
}

// 实现 XSortablePoints 的 Less 方法
func (xsp XSortablePoints) Less(i, j int) bool {
    return xsp.Points[i].x < xsp.Points[j].x
}

// YSortablePoints 用于按 y 轴排序 (这里只是为了演示，实际可直接用 Points)
type YSortablePoints struct {
    Points // 嵌入 Points 类型
}

// 实现 YSortablePoints 的 Less 方法
func (ysp YSortablePoints) Less(i, j int) bool {
    return ysp.Points[i].y < ysp.Points[j].y
}

// CountryIDSortablePoints 用于按 country_id 排序
type CountryIDSortablePoints struct {
    Points
}

func (csp CountryIDSortablePoints) Less(i, j int) bool {
    return csp.Points[i].country_id < csp.Points[j].country_id
}

func main() {
    data := Points{
        {x: 1, y: 5, country_id: 101},
        {x: 3, y: 2, country_id: 102},
        {x: 2, y: 8, country_id: 101},
        {x: 4, y: 1, country_id: 103},
    }

    fmt.Println("原始数据:", data)

    // 按 y 轴排序 (使用原始 Points 类型)
    sort.Sort(data) // data 已经实现了 Less 方法按 y 轴排序
    fmt.Println("按 y 轴排序后:", data)

    // 按 x 轴排序
    // 注意：这里将 data (Points 类型) 转换为 XSortablePoints 类型
    sort.Sort(XSortablePoints{data})
    fmt.Println("按 x 轴排序后:", data)

    // 按 country_id 排序
    sort.Sort(CountryIDSortablePoints{data})
    fmt.Println("按 country_id 排序后:", data)
}

// a function type that returns a boolean
type LessFunc func(p1, p2 *Point) bool

// By 实现了 sort.Interface 接口
type By struct {
    Points
    less LessFunc // 比较函数
}

// Less 方法使用 By 结构体中存储的 less 函数进行比较
func (by By) Less(i, j int) bool {
    return by.less(by.Points[i], by.Points[j])
}

func main() {
    data := Points{
        {x: 1, y: 5, country_id: 101},
        {x: 3, y: 2, country_id: 102},
        {x: 2, y: 8, country_id: 101},
        {x: 4, y: 1, country_id: 103},
    }

    fmt.Println("原始数据:", data)

    // 定义不同的比较函数
    sortByX := func(p1, p2 *Point) bool {
        return p1.x < p2.x
    }

    sortByY := func(p1, p2 *Point) bool {
        return p1.y < p2.y
    }

    sortByCountryID := func(p1, p2 *Point) bool {
        return p1.country_id < p2.country_id
    }

    // 按 x 轴排序
    sort.Sort(By{data, sortByX})
    fmt.Println("按 x 轴排序后:", data)

    // 按 y 轴排序
    sort.Sort(By{data, sortByY})
    fmt.Println("按 y 轴排序后:", data)

    // 按 country_id 排序
    sort.Sort(By{data, sortByCountryID})
    fmt.Println("按 country_id 排序后:", data)

    // 也可以实现更复杂的组合排序，例如先按 country_id，再按 x
    sortByCountryIDThenX := func(p1, p2 *Point) bool {
        if p1.country_id != p2.country_id {
            return p1.country_id < p2.country_id
        }
        return p1.x < p2.x
    }
    sort.Sort(By{data, sortByCountryIDThenX})
    fmt.Println("按 country_id 再按 x 排序后:", data)
}