Go:有没有办法避免执行完整的sort.Interface切片结构？

Question

如果我在Go中有一个数组/切片结构并希望使用sort包对它们进行排序,我觉得我需要实现包含3个方法的整个排序接口:

• 莱恩
• 交换
• 减

似乎Len和Swap应该始终具有相同的实现,无论数组中的struct类型如何.

有没有办法避免每次都使用Len和Swap,或者这只是Go中缺少泛型的限制？

Answer 1

如果要在同一切片类型上实现多个不同的比较操作,则可以使用嵌入来避免每次重新定义Len和Swap.您还可以使用此技术向排序添加参数,例如,根据某些运行时值反向排序或不排序.

例如

package main

import (
    "sort"
)

type T struct {
    Foo int
    Bar int
}

// TVector is our basic vector type.
type TVector []T

func (v TVector) Len() int {
    return len(v)
}

func (v TVector) Swap(i, j int) {
    v[i], v[j] = v[j], v[i]
}

// default comparison.
func (v TVector) Less(i, j int) bool {
    return v[i].Foo < v[j].Foo
}

// TVectorBarOrdered embeds TVector and overrides
// its Less method so that it is ordered by the Bar field.
type TVectorBarOrdered struct {
    TVector
}

func (v TVectorBarOrdered) Less(i, j int) bool {
    return v.TVector[i].Bar < v.TVector[j].Bar
}

// TVectorArbitraryOrdered sorts in normal or reversed
// order depending on the order of its Reversed field.
type TVectorArbitraryOrdered struct {
    Reversed bool
    TVector
}

func (v TVectorArbitraryOrdered) Less(i, j int) bool {
    if v.Reversed {
        i, j = j, i
    }
    return v.TVector[i].Foo < v.TVector[j].Foo
}

func main() {
    v := []T{{1, 3}, {0, 6}, {3, 2}, {8, 7}}
    sort.Sort(TVector(v))
    sort.Sort(TVectorBarOrdered{v})
    sort.Sort(TVectorArbitraryOrdered{true, v})
}

Answer 2

你自己的答案是对的.在你的数组或切片的情况下,Len()和Swap()的实现很简单.像len()Go可以在这里提供原生swap().但是现在使用的接口也可以用于更复杂的数据结构,如BTrees.它仍然允许Sort()函数工作(就像我的并行快速排序,它使用相同的排序接口).