Go语言切片排序优化：利用嵌入避免重复实现Len和Swap方法

package main

import (
    "fmt"
    "sort"
)

// T 定义一个简单的结构体，包含两个整数字段
type T struct {
    Foo int
    Bar int
}

// TVector 是我们基础的切片类型，用于承载 T 结构体
type TVector []T

// Len 返回切片的长度
func (v TVector) Len() int {
    return len(v)
}

// Swap 交换切片中指定索引的两个元素
func (v TVector) Swap(i, j int) {
    v[i], v[j] = v[j], v[i]
}

// Less 默认比较方法，按 Foo 字段升序排序
func (v TVector) Less(i, j int) bool {
    return v[i].Foo < v[j].Foo
}

// TVectorBarOrdered 嵌入 TVector 并重写其 Less 方法，按 Bar 字段排序
type TVectorBarOrdered struct {
    TVector // 嵌入 TVector，自动继承 Len 和 Swap 方法
}

func (v TVectorBarOrdered) Less(i, j int) bool {
    // 注意：这里需要通过 v.TVector 来访问底层切片元素
    return v.TVector[i].Bar < v.TVector[j].Bar
}

// TVectorArbitraryOrdered 嵌入 TVector 并根据 Reversed 字段决定排序顺序
type TVectorArbitraryOrdered struct {
    Reversed bool // 控制是否反转排序
    TVector  // 嵌入 TVector，自动继承 Len 和 Swap 方法
}

func (v TVectorArbitraryOrdered) Less(i, j int) bool {
    if v.Reversed {
        // 如果是反转排序，则交换 i 和 j，使得 Less 方法的比较结果反向
        i, j = j, i
    }
    // 仍然按 Foo 字段排序，但由于 i, j 的交换，实现了反向排序
    return v.TVector[i].Foo < v.TVector[j].Foo
}

func main() {
    // 原始数据
    data := []T{{1, 3}, {0, 6}, {3, 2}, {8, 7}}
    fmt.Println("原始数据:", data) // 输出: [{1 3} {0 6} {3 2} {8 7}]

    // 1. 按 Foo 字段默认排序
    vFooSorted := TVector(data) // 将 []T 转换为 TVector 类型
    sort.Sort(vFooSorted)
    fmt.Println("按 Foo 排序:", vFooSorted) // 输出: [{0 6} {1 3} {3 2} {8 7}]

    // 2. 按 Bar 字段排序
    // 注意：这里需要创建一个新的 []T 切片副本，因为 sort.Sort 会原地修改切片
    dataCopy1 := make([]T, len(data))
    copy(dataCopy1, data)
    vBarSorted := TVectorBarOrdered{TVector: TVector(dataCopy1)} // 嵌入 TVector
    sort.Sort(vBarSorted)
    fmt.Println("按 Bar 排序:", vBarSorted.TVector) // 输出: [{3 2} {1 3} {0 6} {8 7}]

    // 3. 按 Foo 字段反向排序
    dataCopy2 := make([]T, len(data))
    copy(dataCopy2, data)
    vArbitrarySorted := TVectorArbitraryOrdered{Reversed: true, TVector: TVector(dataCopy2)}
    sort.Sort(vArbitrarySorted)
    fmt.Println("按 Foo 反向排序:", vArbitrarySorted.TVector) // 输出: [{8 7} {3 2} {1 3} {0 6}]
}

原始数据: [{1 3} {0 6} {3 2} {8 7}]
按 Foo 排序: [{0 6} {1 3} {3 2} {8 7}]
按 Bar 排序: [{3 2} {1 3} {0 6} {8 7}]
按 Foo 反向排序: [{8 7} {3 2} {1 3} {0 6}]