7.6. sort.Interface接口

排序操作和字符串格式化一样是很多程序经常使用的操作。尽管一个最短的快排程序只要15行就可以搞定,但是一个健壮的实现需要更多的代码,并且我们不希望每次我们需要的时候都重写或者拷贝这些代码。

幸运的是,sort包内置的提供了根据一些排序函数来对任何序列排序的功能。它的设计非常独到。在很多语言中,排序算法都是和序列数据类型关联,同时排序函数和具体类型元素关联。相比之下,Go语言的sort.Sort函数不会对具体的序列和它的元素做任何假设。相反,它使用了一个接口类型sort.Interface来指定通用的排序算法和可能被排序到的序列类型之间的约定。这个接口的实现由序列的具体表示和它希望排序的元素决定,序列的表示经常是一个切片。

一个内置的排序算法需要知道三个东西:序列的长度,表示两个元素比较的结果,一种交换两个元素的方式;这就是sort.Interface的三个方法:

  1. package sort
  2. type Interface interface {
  3. Len() int
  4. Less(i, j int) bool // i, j are indices of sequence elements
  5. Swap(i, j int)
  6. }

为了对序列进行排序,我们需要定义一个实现了这三个方法的类型,然后对这个类型的一个实例应用sort.Sort函数。思考对一个字符串切片进行排序,这可能是最简单的例子了。下面是这个新的类型StringSlice和它的Len,Less和Swap方法

  1. type StringSlice []string
  2. func (p StringSlice) Len() int { return len(p) }
  3. func (p StringSlice) Less(i, j int) bool { return p[i] < p[j] }
  4. func (p StringSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

现在我们可以通过像下面这样将一个切片转换为一个StringSlice类型来进行排序:

  1. sort.Sort(StringSlice(names))

这个转换得到一个相同长度,容量,和基于names数组的切片值;并且这个切片值的类型有三个排序需要的方法。

对字符串切片的排序是很常用的需要,所以sort包提供了StringSlice类型,也提供了Strings函数能让上面这些调用简化成sort.Strings(names)。

这里用到的技术很容易适用到其它排序序列中,例如我们可以忽略大小写或者含有的特殊字符。(本书使用Go程序对索引词和页码进行排序也用到了这个技术,对罗马数字做了额外逻辑处理。)对于更复杂的排序,我们使用相同的方法,但是会用更复杂的数据结构和更复杂地实现sort.Interface的方法。

我们会运行上面的例子来对一个表格中的音乐播放列表进行排序。每个track都是单独的一行,每一列都是这个track的属性像艺术家,标题,和运行时间。想象一个图形用户界面来呈现这个表格,并且点击一个属性的顶部会使这个列表按照这个属性进行排序;再一次点击相同属性的顶部会进行逆向排序。让我们看下每个点击会发生什么响应。

下面的变量tracks包含了一个播放列表。(One of the authors apologizes for the other author’s musical tastes.)每个元素都不是Track本身而是指向它的指针。尽管我们在下面的代码中直接存储Tracks也可以工作,sort函数会交换很多对元素,所以如果每个元素都是指针而不是Track类型会更快,指针是一个机器字码长度而Track类型可能是八个或更多。

gopl.io/ch7/sorting

  1. type Track struct {
  2. Title string
  3. Artist string
  4. Album string
  5. Year int
  6. Length time.Duration
  7. }
  8. var tracks = []*Track{
  9. {"Go", "Delilah", "From the Roots Up", 2012, length("3m38s")},
  10. {"Go", "Moby", "Moby", 1992, length("3m37s")},
  11. {"Go Ahead", "Alicia Keys", "As I Am", 2007, length("4m36s")},
  12. {"Ready 2 Go", "Martin Solveig", "Smash", 2011, length("4m24s")},
  13. }
  14. func length(s string) time.Duration {
  15. d, err := time.ParseDuration(s)
  16. if err != nil {
  17. panic(s)
  18. }
  19. return d
  20. }

printTracks函数将播放列表打印成一个表格。一个图形化的展示可能会更好点,但是这个小程序使用text/tabwriter包来生成一个列整齐对齐和隔开的表格,像下面展示的这样。注意到*tabwriter.Writer是满足io.Writer接口的。它会收集每一片写向它的数据;它的Flush方法会格式化整个表格并且将它写向os.Stdout(标准输出)。

  1. func printTracks(tracks []*Track) {
  2. const format = "%v\t%v\t%v\t%v\t%v\t\n"
  3. tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
  4. fmt.Fprintf(tw, format, "Title", "Artist", "Album", "Year", "Length")
  5. fmt.Fprintf(tw, format, "-----", "------", "-----", "----", "------")
  6. for _, t := range tracks {
  7. fmt.Fprintf(tw, format, t.Title, t.Artist, t.Album, t.Year, t.Length)
  8. }
  9. tw.Flush() // calculate column widths and print table
  10. }

为了能按照Artist字段对播放列表进行排序,我们会像对StringSlice那样定义一个新的带有必须的Len,Less和Swap方法的切片类型。

  1. type byArtist []*Track
  2. func (x byArtist) Len() int { return len(x) }
  3. func (x byArtist) Less(i, j int) bool { return x[i].Artist < x[j].Artist }
  4. func (x byArtist) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

为了调用通用的排序程序,我们必须先将tracks转换为新的byArtist类型,它定义了具体的排序:

  1. sort.Sort(byArtist(tracks))

在按照artist对这个切片进行排序后,printTrack的输出如下

  1. Title Artist Album Year Length
  2. ----- ------ ----- ---- ------
  3. Go Ahead Alicia Keys As I Am 2007 4m36s
  4. Go Delilah From the Roots Up 2012 3m38s
  5. Ready 2 Go Martin Solveig Smash 2011 4m24s
  6. Go Moby Moby 1992 3m37s

如果用户第二次请求“按照artist排序”,我们会对tracks进行逆向排序。然而我们不需要定义一个有颠倒Less方法的新类型byReverseArtist,因为sort包中提供了Reverse函数将排序顺序转换成逆序。

  1. sort.Sort(sort.Reverse(byArtist(tracks)))

在按照artist对这个切片进行逆向排序后,printTrack的输出如下

  1. Title Artist Album Year Length
  2. ----- ------ ----- ---- ------
  3. Go Moby Moby 1992 3m37s
  4. Ready 2 Go Martin Solveig Smash 2011 4m24s
  5. Go Delilah From the Roots Up 2012 3m38s
  6. Go Ahead Alicia Keys As I Am 2007 4m36s

sort.Reverse函数值得进行更近一步的学习,因为它使用了(§6.3)章中的组合,这是一个重要的思路。sort包定义了一个不公开的struct类型reverse,它嵌入了一个sort.Interface。reverse的Less方法调用了内嵌的sort.Interface值的Less方法,但是通过交换索引的方式使排序结果变成逆序。

  1. package sort
  2. type reverse struct{ Interface } // that is, sort.Interface
  3. func (r reverse) Less(i, j int) bool { return r.Interface.Less(j, i) }
  4. func Reverse(data Interface) Interface { return reverse{data} }

reverse的另外两个方法Len和Swap隐式地由原有内嵌的sort.Interface提供。因为reverse是一个不公开的类型,所以导出函数Reverse返回一个包含原有sort.Interface值的reverse类型实例。

为了可以按照不同的列进行排序,我们必须定义一个新的类型例如byYear:

  1. type byYear []*Track
  2. func (x byYear) Len() int { return len(x) }
  3. func (x byYear) Less(i, j int) bool { return x[i].Year < x[j].Year }
  4. func (x byYear) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

在使用sort.Sort(byYear(tracks))按照年对tracks进行排序后,printTrack展示了一个按时间先后顺序的列表:

  1. Title Artist Album Year Length
  2. ----- ------ ----- ---- ------
  3. Go Moby Moby 1992 3m37s
  4. Go Ahead Alicia Keys As I Am 2007 4m36s
  5. Ready 2 Go Martin Solveig Smash 2011 4m24s
  6. Go Delilah From the Roots Up 2012 3m38s

对于我们需要的每个切片元素类型和每个排序函数,我们需要定义一个新的sort.Interface实现。如你所见,Len和Swap方法对于所有的切片类型都有相同的定义。下个例子,具体的类型customSort会将一个切片和函数结合,使我们只需要写比较函数就可以定义一个新的排序。顺便说下,实现了sort.Interface的具体类型不一定是切片类型;customSort是一个结构体类型。

  1. type customSort struct {
  2. t []*Track
  3. less func(x, y *Track) bool
  4. }
  5. func (x customSort) Len() int { return len(x.t) }
  6. func (x customSort) Less(i, j int) bool { return x.less(x.t[i], x.t[j]) }
  7. func (x customSort) Swap(i, j int) { x.t[i], x.t[j] = x.t[j], x.t[i] }

让我们定义一个多层的排序函数,它主要的排序键是标题,第二个键是年,第三个键是运行时间Length。下面是该排序的调用,其中这个排序使用了匿名排序函数:

  1. sort.Sort(customSort{tracks, func(x, y *Track) bool {
  2. if x.Title != y.Title {
  3. return x.Title < y.Title
  4. }
  5. if x.Year != y.Year {
  6. return x.Year < y.Year
  7. }
  8. if x.Length != y.Length {
  9. return x.Length < y.Length
  10. }
  11. return false
  12. }})

这下面是排序的结果。注意到两个标题是“Go”的track按照标题排序是相同的顺序,但是在按照year排序上更久的那个track优先。

  1. Title Artist Album Year Length
  2. ----- ------ ----- ---- ------
  3. Go Moby Moby 1992 3m37s
  4. Go Delilah From the Roots Up 2012 3m38s
  5. Go Ahead Alicia Keys As I Am 2007 4m36s
  6. Ready 2 Go Martin Solveig Smash 2011 4m24s

尽管对长度为n的序列排序需要 O(n log n)次比较操作,检查一个序列是否已经有序至少需要n-1次比较。sort包中的IsSorted函数帮我们做这样的检查。像sort.Sort一样,它也使用sort.Interface对这个序列和它的排序函数进行抽象,但是它从不会调用Swap方法:这段代码示范了IntsAreSorted和Ints函数在IntSlice类型上的使用:

  1. values := []int{3, 1, 4, 1}
  2. fmt.Println(sort.IntsAreSorted(values)) // "false"
  3. sort.Ints(values)
  4. fmt.Println(values) // "[1 1 3 4]"
  5. fmt.Println(sort.IntsAreSorted(values)) // "true"
  6. sort.Sort(sort.Reverse(sort.IntSlice(values)))
  7. fmt.Println(values) // "[4 3 1 1]"
  8. fmt.Println(sort.IntsAreSorted(values)) // "false"

为了使用方便,sort包为[]int、[]string和[]float64的正常排序提供了特定版本的函数和类型。对于其他类型,例如[]int64或者[]uint,尽管路径也很简单,还是依赖我们自己实现。

练习 7.8: 很多图形界面提供了一个有状态的多重排序表格插件:主要的排序键是最近一次点击过列头的列,第二个排序键是第二最近点击过列头的列,等等。定义一个sort.Interface的实现用在这样的表格中。比较这个实现方式和重复使用sort.Stable来排序的方式。

练习 7.9: 使用html/template包(§4.6)替代printTracks将tracks展示成一个HTML表格。将这个解决方案用在前一个练习中,让每次点击一个列的头部产生一个HTTP请求来排序这个表格。

练习 7.10: sort.Interface类型也可以适用在其它地方。编写一个IsPalindrome(s sort.Interface) bool函数表明序列s是否是回文序列,换句话说反向排序不会改变这个序列。假设如果!s.Less(i, j) && !s.Less(j, i)则索引i和j上的元素相等。